An LLM with its default degrees of freedom always produces something plausible, and often something incorrect. Production-grade means dialing those freedoms in — four rungs, in order.
A language model with all its degrees of freedom will always produce something plausible, and often something incorrect. That is not a defect to be trained away — plausible is the one property the machine itself guarantees. Correct is a different property. Correct means matching things outside the model — your prices, your process, your standards — and the model cannot be bound to anything outside itself.
And it never leaves a blank. Every degree of freedom you leave open, it fills with something plausible. A fact it does not have does not become a hole in the output; it becomes an invented fact that reads like a real one. That is why an agent POC works in the demo and fails in production: plausible is enough to pass a demo, and production is where someone needs it to be exact.
So making a POC production-grade is not a matter of granting the agent more, and not a matter of better prompting. It is the work of dialing in the degrees of freedom: pinning each thing that must be exact to something that makes it exact, and leaving the model free only where you actually want judgment. There are four rungs, and each one pins a different freedom.
Two earlier pieces argued the two halves of this — Principled Orchestration for the content, Who Decides the Next Step for the control flow. The ladder is both, applied in order.
Every degree of freedom is open. Content and procedure both live in the model; nothing is inspectable and nothing is versioned. The output draws on whatever training absorbed and whatever the prompt happens to evoke. This rung is useful for exactly one thing: finding out whether the model can do the task at all. Characteristic failure: the content — the model's idea of the task, not yours.
This rung pins the facts. The content moves out of the model into an artifact you can inspect and version; the model becomes answerable to your corpus instead of its training, and the facts are no longer free to vary. Characteristic failure: retrieval — right corpus, wrong piece of it.
This rung names the procedure without pinning it. The steps, their order, and the decision points get written down — but in prose, so the model still interprets them at runtime and decides which step comes next. The same input can take a different path on a different run. Characteristic failure: traversal — the steps are right and the path through them is not.
This rung pins the procedure. It moves into code, behind a tool boundary: the agent still decides to make the call, but everything past the call is fixed and code decides what runs next. The freedom that remains is the one inside each step — the judgment you wanted the model for in the first place. Characteristic failure: your decomposition — a step you never wrote is missing on every run, identically. That is the only failure mode worth having, because it is the only one that holds still long enough to fix.
Take a concrete task: turn a client meeting transcript into a proposal.
| Rung | What runs | What this rung fixes | What still breaks |
|---|---|---|---|
| 1 · Prompt | “Here is the transcript — write a proposal.” | Proves the model can produce something proposal-shaped at all. | Everything specific to the firm: invented pricing, services you do not sell, missing standard terms. |
| 2 · + KB | Same prompt, plus the rate card, service catalog, standard terms, and past proposals. | Pricing and service descriptions become real, and every claim is traceable to a document. | Retrieval: the enterprise template on an SMB deal. And it still drafts in one pass, over-weighting whatever was said loudest in the meeting. |
| 3 · + Stochastic | Named steps, in prose: extract requirements, infer decision criteria, map to service lines, scope, draft, check against pricing rules. | Coverage: the quiet requirement no longer vanishes just because nobody emphasized it. | Traversal: it drafts first and retrofits the check, or skips a step it judges not applicable. The same transcript can produce two different proposals. |
| 4 · + Deterministic | The same steps as code: extraction is a fixed call, pricing is a lookup, the scope check always runs. | Reproducibility — and a bad output is attributable to a specific step. | Your decomposition: you never wrote a step for “client mentioned a competing vendor,” so it is missing every time. Which is why review will catch it. |
Read the last column downward. That is what the ladder buys: not the absence of failure, but failure that moves from unbounded to locatable to fixable.
“How sophisticated is this agent” is not measurable. What fraction of the work sits behind a tool boundary is. That ratio is the maturity metric, and it is the one worth putting on a slide.
Climb when the current rung's failures stop teaching you anything. Each rung has a signature failure, and it doubles as a diagnostic: a team on rung 3 that is still fixing retrieval problems climbed too early, and is now debugging rung 2 with rung 3 machinery.
This is the same motion as prompt to skill to tool in Who Decides the Next Step: harden what has proved itself, and no earlier.
The destination is not zero freedom — a system with no judgment left in it did not need a model. The destination is freedom only where you chose it: facts pinned to a corpus, procedure pinned to code, and the model free inside each step to exercise the judgment you hired it for. The model still performs the work — that never changes. What changes is that nothing else is left to vary.