TL;DR
- Most AI diligence tools check each document against an issues list written before anyone has opened the data room.
- That list is real work. Firms have told us they built 1,000+ prompts, then they don't work on the next deal.
- It also goes stale the moment the data room moves, it can't show where the deal stands, and it stops at an answer rather than a finished report.
- None of this is a question of whose model is better. It's a question of what the system is built to do.
Every AI diligence tool on the market runs the same play. You build an issues list before the deal opens, and the tool checks each document against it, one file at a time. It looks like a lawyer working through a checklist. It isn't.
Four reasons that approach falls down.
1. You can only prepare for the issues you imagined
Every deal is subtly different. Pre-loaded checks leave you ready for the problems you thought of, not the ones waiting in a Chilean mining services company's licensing chain. Generic AI diligence tools will not find them either.
And building the list is harder than it sounds:
- Write the questions before anyone has seen the data room
- Get the wording right across every jurisdiction in scope
- Redo the work for every deal that doesn't look exactly like the last one
If a single check is slightly off, or doesn't account for the context in front of it, the output misses half of what a lawyer would have caught.
We've met firms who spent serious lawyer time getting to 1,000+ hand-crafted prompts just to make a general-purpose tool usable on one deal, then had to rebuild much of it for the next, and the one after that.
2. It goes stale the moment the data room changes
Mid-deal, on any standard diligence:
- New documents arrive
- Old ones are replaced with updated versions
- The same document appears twice under a different name
- A document quietly disappears
A preset question list doesn't know a document changed underneath it. It answers the checklist against whatever is there now. And when the advice changes as a result, nothing reconciles the change or surfaces it for review. Diligence reports are not static. Many tools assume they are. This is just not how lawyers deliver the work in practice.
3. It doesn't know where the deal stands
A large part of diligence is noticing what is missing, raising it, and getting an answer from the client. Firms tell us this is central to how they work and that general purpose AI tooling ignores this entirely.
Nor do lawyers get a visual on the state of the transaction across a deal team. They are built to look inside a document, not across the people working the deal.
4. Answering a question is not finishing a report
A checklist tool stops at the answer: here's the clause, here's the flag. A finished report is something else. It's a document in the firm's voice and template that a partner can send to a client. Getting from one to the other usually means:
- Reformatting an export into house style, which takes an associate many hours
- Rewriting so five specialists' entries read as one voice
- Rebuilding the bullets, numbering, and highlighting lost on export
For many firms, that step takes longer than the review. Averages range from 20 to 90 hours of senior lawyer time.
It was never about the model
Most tools in this space are built on similar foundations. The difference is not whose model is better. It's whether the system works out what the issues actually are, follows up on the gaps, shows where the deal stands, and finishes with something a partner can send.
So, that's what we built.
Deeligence runs agentically. The agents, pre-trained and honed by our AI and legal engineers, work across the whole data room rather than one document at a time, test their findings against each other, do real legal research against sources you can stand behind, and hold the shape of the transaction in view the whole way through. They chase the loose threads and they produce the finished report. Lawyers and engineers tune the agents in advance, so it is effective on every deal out of the box rather than after a thousand prompts.
What comes out the other side:
- Issues that only surface when documents are read against each other
- Amendments and side letters tied back to the agreements they vary
- A flag when a document points to something that never made it into the data room
- Far less noise to wade through
- Findings that matter, because the system understands the deal and not just the file in front of it