AI should discover. Deterministic systems should execute.
Enterprise AI in Production - Part 4 of 5
The last three parts made the case: production wants predictability, reasoning should be expensive-but-temporary, and trust is built from determinism. This part is the architecture that ties it together - the part I most want other technical leaders to poke holes in.
Stop drawing the box around "everything"
The default agentic architecture looks like this:
Request → Autonomous Agent → Everything
One reasoning loop, unbounded authority, every path handled by the model. It's seductive because it's simple and it demos well. It's also the architecture you can't cost, can't audit, and can't guarantee.
The architecture I'd argue for instead splits the world by what kind of problem you're facing:
- Known problems → deterministic execution
- Unknown problems → AI reasoning
- Validated learning → converted into rules
AI becomes the discovery engine. Deterministic systems become the production engine. And there's a ratchet in the middle that moves work from the first to the second, permanently, as it becomes well understood.
The two engines
Think of your platform as having two distinct halves with different jobs.
The discovery engine is where reasoning lives. It handles the ambiguous, the novel, the long tail of exceptions that no one anticipated. It's flexible, powerful, and - by design - expensive and non-deterministic. You point it at problems you don't yet have a clean answer for. You keep it under supervision, because that's exactly where the risk is.
The production engine is where execution lives. It handles the known, the high-volume, the well-understood. It's cheap, fast, reproducible, and auditable. It doesn't reason - it runs. This is where the vast majority of your traffic should eventually land.
A healthy system pushes as much load as possible from the first engine to the second over time. If everything stays in the discovery engine forever, you've built a very expensive way to do routine work - and you'll be one of the projects that gets cancelled for cost.
The ratchet: from reasoning to rules
The connective tissue is a deliberate, one-directional process. It has a rhythm to it:
Observe. The discovery engine solves a class of problems. You watch it. You log what it does and why.
Validate. Once it solves that class reliably and repeatedly - with outcomes you can measure - you flag it as a graduation candidate. The bar is repeatability, not a single lucky success.
Convert. You capture the behavior as a deterministic path: a rule, a workflow, a decision table, a small piece of ordinary code. Now it's explainable by construction and it costs a rounding error to run.
Guard. You keep the discovery engine watching the edges. When the deterministic path hits an input it doesn't cover, it doesn't guess - it escalates back to reasoning. The exception becomes the next thing worth learning from.
The ratchet only turns one way. Work graduates from reasoning to execution and stays there, while genuinely novel cases keep flowing to the engine built to handle them. Your system gets cheaper and more predictable precisely because it keeps learning - the opposite of the usual trade-off.
Why this beats "just make the agent better"
You could try to solve cost, trust, and reliability by making one monolithic agent smarter. But you'd be fighting the nature of the tool. Reasoning is inherently variable; that's what makes it good at ambiguity and bad at guarantees. No amount of prompt engineering turns a probabilistic reasoner into something you can put a hard SLA on.
The two-engine model doesn't fight that nature - it puts each capability where its strengths are load-bearing and its weaknesses don't matter. Reasoning does what only reasoning can. Execution does everything reasoning has already figured out. And the boundary between them is something you actively manage, not something you hope the model handles internally.
A note on model risk
There's a strategic bonus here. When a model upgrades or you swap providers, a fully agentic system's behavior can shift in ways that are hard to predict and harder to regression-test. But everything you've graduated to the production engine is insulated - it's deterministic code and rules that don't change when the model does. The more work you've ratcheted across, the less exposed you are to the thing you control least: the model underneath you.
Discover with the model. Execute without depending on it. That's how you stay both cutting-edge and stable at the same time.
This is Part 4 of a five-part series. Next, the closer: why so many pilots die before production - and what separates the survivors.
If you're running a two-engine or hybrid setup: how are you deciding when a behavior has "graduated" from reasoning to a deterministic path? The validation bar is the hardest part to get right, and I'd love to hear how others are drawing it.
About the Author
Praveen R is VP, Software Development at Founding Minds. He leads global software development teams and brings 13+ years of product experience across ERP, CRM and e-commerce. He has built fintech and healthcare products since 2013.
