Most "AI agent" demos involve fairly forgiving domains, drafting a marketing email, summarizing a meeting. Legal contract review is a much less forgiving one: a missed clause or a misread definition has real financial and legal consequences.
Definely, a London legaltech company, recently shipped a multi agent product for contract review, and the architecture decisions behind it are a useful reference point for anyone building agentic systems in a domain where "the agent got it mostly right" isn't good enough.
Why single-agent chat interfaces don't hold up here
The obvious way to bolt AI onto contract review is a chat box: paste in a clause, ask a question, get an answer. That works fine for isolated questions but breaks down for the actual task lawyers do, which involves cross referencing definitions scattered across a hundred page document, checking clause consistency, and flagging deviations from a firm's standard language, simultaneously, across a document that has internal dependencies.
A single general purpose agent handling all of that in one pass tends to lose track of context as the task complexity grows. Definely's approach instead splits the work across a set of specialist agents, one focused on clause analysis, another on summarization, others on different sub tasks, coordinated through what's described as a single natural language interface rather than the user manually invoking each one.
The architectural bet: narrow, coordinated agents over one generalist
This is the more interesting engineering decision. Instead of one large agent trying to hold the entire contract review task in its context window and reasoning path, the system decomposes the task into narrower sub problems, each handled by an agent scoped tightly enough to be evaluated and trusted independently.
*That decomposition matters for a few concrete reasons if you're building something similar:
*
Evaluation gets tractable. It's much easier to measure and improve accuracy on "does this agent correctly extract defined terms" than on "does this agent correctly review an entire contract end to end." Narrow scope means narrow, testable failure modes.
Errors are more contained. If one specialist agent underperforms on a particular clause type, it doesn't necessarily degrade the whole pipeline's output, versus a single monolithic agent where one weak reasoning step can cascade through the entire response.
Coordination becomes the hard part instead of raw capability. Once you've split the task, the actual engineering challenge shifts to orchestration, deciding which agent runs when, how their outputs get reconciled, and how to present a coherent result to the user instead of five disconnected agent outputs stitched together.
Living inside the existing workflow instead of replacing it
A detail worth noting: rather than building a standalone app lawyers have to switch into, the product is integrated directly into Microsoft Word, where legal drafting already happens. That's a deliberate constraint on the agent design too, agents operating inside a live document need to respect existing formatting, track changes conventions, and not disrupt a workflow lawyers already trust.
Building agentic tooling into the tool people already use is a meaningfully harder integration problem than a fresh standalone interface, but it's usually the difference between something that gets adopted and something that gets tried once and abandoned.
The trust problem is the actual product problem
In a regulated, high-stakes document domain, the hardest part of shipping agentic AI isn't raw model capability, it's getting professionals who are personally liable for their work product to trust an agent's output enough to rely on it.
That pushes design decisions toward transparency: agents that can point to exactly which part of the document informed a given flag, rather than opaque end to end outputs. If a lawyer can't trace why an agent flagged something, they can't responsibly sign off on it, which means the agent hasn't actually removed work, it's just added a verification step that's just as time consuming as doing it manually.
The takeaway
If you're building agentic systems for any domain where the cost of an error is high, medical, legal, financial, the generalizable lesson here isn't "use more agents." It's that decomposing a complex task into narrowly scoped, independently evaluable sub agents makes the system more debuggable and more trustworthy, even if it adds real orchestration complexity.
The interesting engineering work in agentic AI right now isn't making one agent smarter, it's figuring out how to split a genuinely hard task into pieces small enough to verify.
If you want the full funding history and business context behind Definely, you can read more on Entrepreneur Plus UK.
