AI document automation works best at design time. Martin Srubar explains why generative models don’t belong in the run-time production of binding contracts.
There’s a line I draw through AI document generation: AI belongs at design time. Template authoring, data mapping, test generation, migration of legacy content, working out what an existing template portfolio actually does: these are jobs where a probabilistic system, with a person reviewing its output, beats the alternative outright.
Run time is different. The document itself should be deterministic: same inputs, same output, every time, provably.
The reason isn’t because AI disappoints, but more that the core value of document automation software was never speed. Instead, it was that the output is predictable and can be proven correct before anyone relies on it. Move the generation step to a probabilistic system and you give that up, whatever you gain elsewhere.
Some readers will call this AI skepticism. That’s a mislabel: this is a claim about where in the pipeline a probabilistic system earns its place, and there are places it earns that decisively.
Why humans were replaced in the first place
Software took over document production because humans make mistakes per instance. Speed was a bonus.
A person drafting from precedent gets it right nine hundred and ninety-nine times, then on a Thursday afternoon copies the wrong paragraph into one contract. The error isn’t systematic and it doesn’t repeat. It’s one wrong document sitting inside a large pile of correct ones, and at real volume nobody finds it until it matters.
Deterministic templates fixed that by relocating the error. All the risk moved to authoring time: one artefact, tested exhaustively, reviewed by people who know the subject, approved once, then correct across a million instances. That relocation is the value proposition of document automation software.
What AI genuinely added is different. It handles unstructured input, which traditional document automation platforms never could: reading a messy instruction, extracting structure from a document nobody templated, interpreting a request that doesn’t fit a form. That’s a real expansion of what can be automated, and it belongs at the front of the pipeline, where the inputs are messy.
Where the error lives
Generative document production, whether that’s a large language model or another generative system, undoes the relocation. The error goes back to being per-instance, sitting somewhere nobody is checking, with a failure mode worse than the human one: fluent, plausible, internally consistent, and legally binding.
Run the arithmetic on your own volumes. At a hundred thousand documents a month, a system that’s right 99.99% of the time produces a wrong document roughly twice a week. Four nines sounds like an engineering triumph until you write it out as ten wrong contracts every month, indefinitely.
The detection problem is worse than the error rate. A deterministic defect is systematic: it shows up in testing, or it shows up in every document at once and someone notices by Monday. You fix the template, regenerate, move on. A generative error is one paragraph in one contract that reads exactly like the correct paragraph would. Nothing flags it. The system reports success. You find out from a customer, or from a regulator.
That asymmetry (concentrated and visible versus distributed and invisible) is the whole argument. It doesn’t depend on models being bad, and it doesn’t get resolved by them getting better in the ways they’re currently getting better.
Three error categories
There’s a tempting shortcut here: describe the content in rules and automate it deterministically, then hand everything else, anything a person would have to write to AI.
That’s clean, and wrong at the edge. It puts AI exactly where human judgement was required, which is where the consequences run highest and the errors are hardest to catch. The bespoke clause a lawyer drafts is the risky part of a contract. The boilerplate around it is not.
A better axis is cost of error multiplied by detectability, and it splits into three categories rather than two.
The first is rules-describable content: deterministic, always. This covers most enterprise document content, and the fact that it’s unglamorous isn’t an argument against it.
The second is human-written and consequential: AI drafts, a person reads and signs. This is where most of the real productivity gain sits, and also where the human needs to stay in the loop, not as a formality, but because they’re the one who can be held responsible for the result.
The third is human-written and low-consequence: summaries, covering notes, internal explanations. Generative output is fine here.
Most enterprise enthusiasm is aimed at the middle category. So is most of the risk, because that’s where removing the human looks like the biggest win.
A claim you can hold me to
Predictions that can’t fail aren’t worth making, so here’s one that can.
By 2029, no top-tier institution in banking, insurance, or government will place a generative model in the unreviewed production path for binding contractual text.
What would prove me wrong is public: a named institution standing behind unreviewed generative production of binding text, on the record, and it holding up. If that happens, I was wrong about something structural, not a detail. The other failure mode plays out just as publicly, with the opposite outcome: it doesn’t hold up, in court or in a regulator’s findings. That would falsify my prediction and vindicate the rest of this article. I’ll take that trade.
Let me argue the other side properly, because there’s a serious counter. The mitigation that would defeat me is generate-then-verify: let the model produce the text, then check it against a rules engine, or constrain the generation so it can only produce compliant output. Verified generative output could, in principle, be as reliable as a template.
My answer is that verification eats itself, at every strength you try it at.
Verify completely, and you have to express the rules first: fully, unambiguously, in a form a machine can evaluate. That work is the deterministic template. The generative step becomes an expensive detour to what the rules already specified, plus a component that can fail on its own.
Verify partially, and you’re checking that mandatory clauses are present and prohibited terms are absent. The errors generation introduces are semantic: a plausible clause with one condition inverted, an obligation quietly moved from one party to the other. A checklist can’t see those by construction. Partial verification catches the mistakes a deterministic template wouldn’t have made, and misses the ones AI invents.
Constrain the model to assembling pre-approved clauses, and you’ve built a probabilistic rules engine. Clause selection is either describable in rules, in which case use the rules, or it’s a judgement call, in which case it belongs to the person who signs. I haven’t yet seen the document that needs a third option.
If you think that’s wrong, that’s the interesting disagreement, and a much better conversation than arguing about whether the models are impressive. They are.
The risk is already live, somewhere else
I’ll finish by moving the problem, because I think the debate is well-behaved exactly where the stakes are obvious, and badly behaved where they aren’t.
Nobody serious is proposing an unreviewed AI-generated contract. The people who own document production understand what they’re protecting.
Meanwhile, organisations are deploying chat interfaces that would never pass muster in a CCM platform or a document automation system. They make statements that bind the company anyway, with none of the template governance, approval workflow, version control, or audit trail that either discipline earned the hard way, and often no durable record of what was said to whom. In February 2024, a Canadian tribunal held Air Canada liable for incorrect bereavement-fare information its chatbot gave a passenger, and rejected the argument that the chatbot was a separate entity responsible for its own statements.
Binding text is leaving the building through a channel that got classified as customer service.
So the deterministic-versus-generative line isn’t a niche debate inside document automation software. It names a governance discipline that document and contract automation people spent thirty years building: controlled authoring, review before release, versioning, provable output. The rest of the business now needs that discipline and mostly doesn’t have it.
The real question is whether what AI writes gets the same controls as everything else that binds you, not whether it’s allowed to write at all.
ActiveDocs builds document automation software that works with Microsoft Word: template design, template governance, conditional logic, approval workflow, version control, and audit trails, for banks, insurers, government agencies, and healthcare organisations running contract automation and other compliance-critical document generation at volume. If you want a second opinion on where AI belongs in your own pipeline, get in touch.
Martin Srubar is Senior Technology Evangelist at ActiveDocs. He works with prospects and customers on where document automation fits their architecture, and feeds what he hears back into product direction.