Yesterday your AI agent delivered.
The worklist was complete. The checks passed. The output was well-formed. Nothing was obviously broken. No missing section. No failed test. No malformed result.
Then you read it.
And something was off.
Not wrong. Off.
Every fact was correct. Every requirement was technically satisfied. But the output was centered on the wrong thing. It optimized for completeness when you needed a decision. It hedged when you needed a position. It produced a competent answer to a question adjacent to yours.
You could not file a bug. The agent did exactly what a reasonable agent would do.
That is the problem.
In my previous article, I asked: when an AI says "done", what is done?
That question was about completion. Agents can mark work as finished even when work was skipped, hooks were bypassed, or state was misrepresented. The structural answer was the Skill Operating Contract: make "done" machine-checkable before execution starts, so completion is verified rather than self-declared.
This article is about the failure mode underneath that.
A contract can verify that declared conditions were met.
It cannot verify that the declared conditions were yours.
When an agent finishes and the work is not incomplete, but still wrong in direction, you are not looking at silent completion.
You are looking at silent convergence.
The Junior Developer Analogy Works — Until It Doesn't
At first, this feels familiar.
It feels like managing a junior developer or analyst who misread the brief.
You ask for "the Q3 situation." They return a polished, exhaustive document. Every number is sourced. Every section is complete. The document is not bad. But you needed the two decisions the board has to make, not a factual survey.
Both outputs could reasonably be called "the Q3 situation."
The mismatch is not about quality. It is about frame.
You and the junior were pointing at the same deliverable, but you were collapsing the work around different centers. You wanted decision pressure. They optimized for coverage.
This is a frame mismatch, not a defect.
And that is why it survives polish. You can make the wrong-framed document more thorough, better formatted, and more rigorous, and it remains wrong. The problem is not on the page. The problem is the axis around which the page was organized.
With a human junior, this is usually repairable.
They sit in the same meetings. They absorb what the organization cares about. They learn which tradeoffs matter this quarter. Their guess is biased toward the local environment. And when they miss, feedback changes their future behavior.
Over time, they become the person who "just gets it."
A human junior self-corrects through two mechanisms:
- Their guess is biased toward a shared organizational context.
- Their mistakes accumulate into learning.
That is where the analogy breaks.
An LLM has neither mechanism.
The LLM Does Not Learn Your Axis
When an LLM fills in an unstated frame, it does not lean toward your organization's center of gravity.
It leans toward the population average.
It has been trained on a broad distribution of how people generally write, judge, explain, prioritize, and resolve ambiguity. When your judgment axis is missing, the model does not wait for it. It supplies the most generally reasonable one.
That looks helpful.
It is also dangerous.
The junior's guess is an approximation of your shared context.
The LLM's guess is the absence of your context, covered with the global default.
The second difference is learning.
A junior can internalize correction. You say, "Not like that — I needed the decisions," and the next time the frame changes.
An LLM does not become your junior through repeated correction in the same organizational sense. It can use context inside a session. It can follow examples you provide. But it does not structurally accumulate your organization's judgment axis as a person would.
The missing axis is not missing information that the model can discover by trying harder.
It is a value choice that has not been supplied.
And value does not live inside the training distribution.
This is the load-bearing distinction:
The mechanism that produces the mismatch looks similar in a junior and an LLM.
The mechanism that removes the mismatch exists in the junior and does not exist in the LLM.
The most expensive mistake in AI-assisted work is importing the management expectation from humans: "It will get it eventually."
For a junior, that expectation is often correct.
For an LLM, it is structurally false unless the judgment axis is explicitly supplied.
Convergence Has a Subject
Before an AI says "done", it has already converged.
That is what LLMs are good at. They collapse a large space of possible responses into one output. Given enough context, they produce a coherent answer.
But convergence always has a subject.
Converged toward what?
There are two very different answers:
- Convergence to the distribution: the model settles on what is broadly likely, reasonable, and expected.
- Convergence to your judgment: the output lands on the tradeoff your team, project, or organization would actually choose.
The model can do the first by default.
It cannot know the second unless you supply it.
Your specific judgment axis is not automatically present in the prompt. It is not guaranteed to be present in the documentation. It is not guaranteed to be inferable from the task description.
The model may still converge cleanly.
That is the trap.
From the model's point of view, a clean convergence to the global default and a clean convergence to your judgment can look identical. The answer is coherent. The structure is complete. The checklist passes.
The agent reports success.
But it has converged to the average, not to you.
That is silent convergence:
The model collapses to the population default and reports it as done, with no signal that your judgment axis was never present.
Silent completion is easier to catch. Something is missing. A hook did not run. A file was not changed. A test was skipped.
Silent convergence is harder.
The output is complete, coherent, and reasonable.
Reasonable to everyone.
That is exactly the problem.
It is no one's answer in particular, and it is being handed to someone in particular.
Non-Convergence Is Often a Useful Signal
This also changes how we should interpret model uncertainty.
When an LLM cannot settle, the usual reaction is to treat that as weakness. Add more instructions. Run another loop. Force a final answer.
Sometimes that is correct.
But often, non-convergence is a signal.
The model may be exposing a missing judgment axis.
There may be two incompatible goods in play:
- speed versus accuracy
- local fix versus architectural correction
- customer-specific workaround versus product-level design
- completeness versus decision clarity
- safety versus convenience
If no value has been supplied to choose between them, there is no legitimate gradient toward one answer.
The model hesitates because the task is asking it to resolve something that belongs to a human owner.
The failure to converge is not always the model failing at its job.
Sometimes it is surfacing the exact point where human judgment is required.
But silent convergence is more dangerous because the missing axis does not always produce hesitation.
The model may converge anyway.
It may choose the global default, produce a polished answer, and mark the work complete.
So the real rule is not merely:
Escalate when the model cannot converge.
The stronger rule is:
Do not let the model converge on a question that has no supplied judgment axis — even when it can.
This is not a humility rule.
It is a control rule.
It prevents the model from substituting the global default for your judgment.
The Axis Must Come Before Execution
The design implication is straightforward.
The judgment axis has to be supplied externally, before convergence, every time.
Externally, because it is not inside the model.
Before convergence, because once the model has collapsed the problem into an answer, the default has already shaped the output.
Every time, because the model does not internalize the axis the way a human junior does.
This is the part completion contracts alone do not solve.
A Skill Operating Contract can verify that declared conditions were met. But the declared conditions themselves encode judgment. Someone must decide what matters before the agent starts.
That decision cannot be outsourced to the same model that needs the axis.
This is the human gate.
Not a fallback when the AI gets stuck.
Not a final review after the AI says done.
The human gate is the designated place where the one thing the model cannot supply is provided: an owned judgment axis.
"Owned" matters.
A value choice selects among incompatible goods. That selection must belong to someone. It must be traceable, revisable, and accountable.
The population average belongs to no one.
It cannot be corrected because no one chose it.
Only a person, team, or accountable role can own the axis.
What To Build
In practical AI-agent systems, this means the pre-execution step matters more than it looks.
Before the agent begins work, the human gate should supply at least four things.
First: the optimization axis.
What should the work collapse around?
Examples:
- optimize for decision clarity, not completeness
- optimize for minimal safe change, not architectural cleanup
- optimize for traceability, not speed
- optimize for customer impact, not internal elegance
Second: the non-negotiables.
What must not be traded away?
Examples:
- do not change public APIs
- do not bypass existing review hooks
- do not invent requirements
- do not silently ignore ambiguous business rules
Third: the escalation triggers.
Where must the model stop instead of guessing?
Examples:
- when two valid designs require different business priorities
- when a requirement is underspecified
- when a change affects ownership boundaries
- when the safest technical answer conflicts with delivery pressure
Fourth: the completion contract.
What concrete evidence proves the work is done?
Examples:
- tests run and results recorded
- affected files listed
- assumptions declared
- skipped work explicitly marked
- decision points linked back to the supplied axis
Without the first three, the fourth is not enough.
A completion contract can verify that the task closed.
It cannot tell you whether the task closed around the right center.
This Is Not "AI Is Worse Than a Junior"
The tradeoff is more interesting than that.
A human junior can internalize your axis. That is useful. But it also makes the axis implicit. It lives in someone's head. It varies by person, mood, memory, and local exposure. It may never be written down. When that person leaves, the axis leaves with them.
An LLM does not internalize the axis. That is inconvenient. But it creates a different advantage: the axis has to be externalized.
Because it must be supplied every time, it can be written down every time.
That makes it traceable.
It makes it reviewable.
It makes it auditable.
The junior gives you self-repair with buried reasoning.
The LLM gives you no self-repair, but the opportunity for fully externalized reasoning.
Neither is automatically superior.
The design mistake is pretending we have the first tradeoff when we actually have the second.
Where This Leads
This is the layer above completion.
Completion asks:
Did the agent do what it said it would do?
Silent convergence asks:
Who decided what it should converge toward?
If the answer is unclear, the model will supply one.
It will converge to the most generally reasonable answer.
It will produce something clean, complete, and defensible.
And it may still be wrong for you.
This is why AI-agent work needs both parts:
- a completion contract that makes "done" structurally verifiable
- a human gate that supplies the judgment axis before execution
The implementation I am building around this idea is XRefKit.
The Skill Operating Contract verifies completion.
The human gate supplies the axis the contract verifies against.
Those are not separate features. They are two halves of the same control problem.
Because when AI says "done", it has converged.
The real question is:
Converged to whose judgment?
If you cannot answer that, the answer is probably not yours.
It converged to the average.
And the average was not why you asked.
