Last year I worked with a logistics company that had automated invoice processing with an AI agent. The agent read invoices, extracted line items, matched them to purchase orders, and approved payments. End to end. No human in the loop.
It worked beautifully for three months. Then the agent approved a $340,000 payment to a vendor who submitted a duplicate invoice with slightly different formatting. The model treated it as new. The validation layer didn’t exist because “the AI handles it.”
Three hundred and forty thousand dollars. Because someone treated a probabilistic system like a deterministic one.
That experience crystallized a principle I repeat often: AI decides, deterministic code acts. Never the other way around.
The Architecture That Survives
The separation is simple in concept and surprisingly rare in practice. The AI component receives structured context, produces a structured decision with a rationale, and stops there. Everything after that – validation, side effects, and the actual work – is deterministic code with explicit rules.
The flow:
- Trigger arrives with metadata (a ticket, a document, an event)
- AI decision produces structured output – classification, extraction, routing recommendation, confidence score, and a short explanation of why
- Deterministic validation checks the decision against hard policy rules, allowlists, deny lists, and threshold constraints
- Action or escalation – if validation passes and confidence is high, execute. If not, route to human review with the full context attached
- Audit trail stores the input, the decision, the rationale, the validation result, and the final action
Every step is logged. Every decision is replayable. If something goes wrong, you can trace exactly where and why.
Confidence Tiers Aren’t Optional
Not every AI decision deserves the same treatment. A classification the model is 95% sure about is different from one it’s 60% sure about. Your automation should know the difference.
I use three tiers everywhere:
- High confidence – auto-approve, execute the action, log for periodic review
- Medium confidence – queue for human review with the AI’s recommendation and rationale attached
- Low confidence – escalate immediately, flag for manual handling, don’t proceed
Thresholds depend on your domain. For invoice processing, I set the bar high because the cost of a wrong action is real money. For ticket triage, I set it lower because a misrouted ticket is annoying but recoverable.
The point is that uncertainty is a normal operating state. It isn’t a bug. Your system should be designed to handle it gracefully instead of pretending every decision is confident.
Context Discipline
Feed the AI the minimum context needed to make a good decision. Not a raw database dump. Not the entire ticket history. Use a structured package: the specific document or event, the relevant policy excerpt, and a few representative examples of how similar cases were decided.
When teams dump everything into the context window, two things happen: token costs explode, and the model starts hallucinating connections between unrelated data points. More context isn’t better context. Be deliberate about what matters for a specific decision.
Where AI Automation Actually Fits
Good fits: request triage, document classification, data extraction from messy formats, policy-based routing where ambiguity is expected and escalation is normal.
Bad fits: anything safety-critical, anything requiring hard real-time guarantees, anything where a wrong decision is irreversible and expensive. If you can’t tolerate occasional uncertainty, don’t automate with a probabilistic system.
From what I’ve seen, the most successful automation projects started with a single workflow that already had a manual review path. They ran the AI in shadow mode first, compared its decisions to the human decisions, measured agreement rates, and only then moved to live execution – with review still in place for the first few weeks.
The Real Lesson
That $340,000 duplicate payment wasn’t a model failure. The model did exactly what it was designed to do – it classified the invoice and approved it. The failure was architectural. Nobody built the validation layer that should have caught a duplicate vendor-amount-date combination. Nobody defined the hard boundaries.
AI automation works when you respect what it is: a probabilistic decision engine. Wrap it with deterministic guardrails, log everything, and keep humans in the loop for anything your business can’t afford to get wrong.
Guardrails beat talent. Always.