The demos created an instinct: if the model can do anything, put it everywhere. Agents planning, deciding, calling tools, checking their own work. We went through that phase too, and ended up pulling most of it back out. What survives in production has a much less glamorous shape: mostly deterministic steps, with AI in a few specific places.
Look inside any automation that has run unattended for a few years: fetch the statement, parse the file, match on reference number, post to the ledger, send the receipt. Nearly every step is deterministic on purpose: same input, same output, every time, explainably.
Two parts to this:
- why the boring parts must stay boring
- where the model does earn its seat
Why the boring parts must stay boring
A deterministic step can be tested before it runs, audited after it runs, and reasoned about when it fails. It costs nothing and behaves the same on run one and run ten thousand. Put a model where a rule belongs, and all of that degrades at once: the step can't be exhaustively tested anymore, "why did it do that" has no short answer, it becomes slower and metered, and it picks up a failure mode rules don't have: being confidently wrong.
Matching bank transfers has no business being probabilistic. Neither does VAT calculation, deadline arithmetic, or checking whether an amount exceeds an approval threshold. If a step can be expressed as a rule, expressing it as a rule is the whole job.
Where the model earns its seat
None of this means AI doesn't belong in processes. It belongs at the judgment points, the steps where rules run out:
- messy input into structure: a scanned invoice arrives (photographed handwriting included), and supplier, amount and date need extracting; no rule survives real-world documents
- classification under ambiguity: is this email a complaint, an order change, or spam? which cost center does this line belong to?
- drafting for human review: the response, the summary, the proposed entry: model writes, person approves
- routing when signals conflict: the cases where the old process said "ask Sandra", etc
The shape that holds up: a deterministic backbone, AI at the joints, and structure around every AI step: validate the output, define the fallback, hand to a human when confidence drops. Counting steps in flows built this way, it usually lands near one AI step in ten or twenty. That's not a compromise position between enthusiasts and skeptics; it's what the working systems actually look like. Platforms in the Process Execution Layer category are built around this shape: deterministic by default, AI as one module type among many.
The second opinion
For judgment points that carry real consequences, we borrowed a pattern finance teams already use for people: dual control.
Ask two different models the same question, independently: different providers, separately phrased prompts, no shared context. If they agree, proceed automatically. If they disagree, stop and hand the case to a person. The disagreement itself is the signal: it marks exactly the inputs where machine judgment is unreliable, at the cost of one extra API call.
The independence does the work: two calls to the same model mostly share the same blind spots, while two different models fail differently, which is what makes their agreement worth something. It took us a while to appreciate the side effect: the disagreement log turns into a collection of your process's hardest cases, and that tells you where automation should stop better than any benchmark.
A reading test
A quick way we review proposed automations: read the flow like a document and ask which sentences are creative. A good flow reads like a contract with two or three carefully chosen creative sentences in it. And everyone involved knows which sentences those are, what happens when they're wrong, and who gets the case when they disagree.
If the whole document is creative, it isn't a process yet. How does the ratio look in your flows? Happy to compare notes!