A recent Oracle Developers article describes agent loops at three levels:
a basic loop that calls tools and returns a result, a stateful loop that carries memory across steps, and an advanced harness that owns context engineering and routing. The model is useful because it explains why many agent failures come from running a task at the wrong level.
But while building and operating these loops myself, I found another layer the model does not name: the point at which the system is allowed to declare the work finished.
I build the pipelines, define the contracts, implement the control mechanisms, and validate the resulting artifacts. The failures that cost me the most did not come from the level of the agent loop. They came from the governance layer above it, where incomplete work was forced toward a verdict because the state model had no legal place for uncertainty.
That layer has no maturity model. It usually has two words: pass and fail.
The controls I thought would be enough
I am building an AI decision workspace through a multi-agent development system. One agent turns an approved contract into implementation. A separate agent validates an exact frozen result from a clean context, without access to the implementer’s reasoning. I own the scope, accept or reject deferrals, and decide when an attempt is allowed to continue. The roles were separated deliberately: an agent that grades its own output tends to grade the intention behind it, while an independent validator can inspect only what was actually produced.
A verdict expires the moment the artifact changes. Partial approval closes only its declared scope. Blocking categories — state model, permissions, cost visibility, execution lifecycle — cannot be signed off by the agent that built them.
Many teams stop before this layer. I had implemented it, and it still failed to answer the stopping question.
The failure it did not prevent
One semantic contract went through four consecutive revisions. Each one closed every gap the previous verdict named. Each one was submitted to independent validation. Each one failed.
The first verdict found a cluster of underdefined lifecycle and state rules. The second found a smaller set of gaps in causality, defaults, and privacy. The third, fewer still, one layer deeper: cross-stage cardinality, observation time, the physical consequence of a default.
No verdict was wrong. Every revision was better than the one before it. The loop still did not converge.
Separating execution from validation removes one failure class. It does not tell the system when to stop. A validator asked “is this complete” will always find the next layer, because a semantic contract has no natural floor. “No remaining objection” is a property of the reviewer, not of the document.
A loop that cannot terminate on uncertainty can only keep searching for approval or be abandoned from outside.
What I changed, and what it cost
I added states.
Insufficient evidence became a terminal verdict, not a missing one. Not measured became a recorded state, distinct from failed. A failed pre-execution package now terminates the attempt — no repair, no second cycle, no fallback to a standby method. A deferral is legal only when it is explicit, written to a durable artifact, non-blocking, and accepted by name.
Termination does not mean that the problem may never be revisited. It means that continuation is no longer automatic: a new attempt requires a new decision, identity, scope, and evidence basis.
Then I made the decisions those states forced.
A large execution package failed its single pre-flight check: it described the same component two different ways. It was terminated before a single paid model call and never rebuilt. A candidate database change failed its gate; instead of merging it or deleting it, I quarantined it as an immutable, explicitly non-canonical artifact, because a failed change that stays ambiguous will eventually be read as truth. After four implementation-first attempts failed at the gate, I stopped writing code and moved the contract in front of the implementation.
The cost is not abstract. Over that period the system produced specifications, verdicts, and evidence. It produced no user-visible capability. Throughput fell. What improved was the system’s ability to state what it does not know.
I am not presenting that as a win. It is the trade I chose with the information I had, and it is still being tested.
Why this is an AI problem, not a process problem
Deterministic systems do not automatically know when the work is complete, but unresolved states usually surface through mechanical signals: a violated invariant, a missing value, a failed assertion, an exception, or an output that does not match the contract. Those signals are imperfect, but they create observable resistance to moving forward.
A probabilistic system can cross the same boundary without losing fluency. It can produce a complete-looking contract, a coherent review, and a confident next step while the underlying question remains unexamined. Nothing in the language reliably distinguishes “resolved” from “not yet inspected.” The system can therefore generate forward motion for as long as the surrounding architecture permits it, with every individual step appearing reasonable.
So the stop condition has to be designed. It cannot be inherited from failure, because failure no longer announces itself.
This is what the loop levels do not cover. They describe how much capability the loop has, not the rule that ends it. A memory-aware loop remembers more. An advanced harness routes better. Neither knows when the work is done, and neither can say “unknown” unless someone above it made that state legal to occupy.
The primitive is older than the problem
Years earlier, I built a learning product around spaced repetition. Each word was an entity with a state: new, don’t know, in memory, know well. “Don’t know” was not a failure state. It was a legal, first-class position with its own transitions and review interval. A learner who has seen a word and cannot recall it is in a real state, not in an absence of one.
I built that model for a user’s vocabulary and failed to build it for my own workflow. The primitive transfers. Any system that produces judgments needs a state for “not determined yet” — and a rule for how long it may stay there.
A system that cannot record “unknown” does not become uncertain. It becomes agreeable.
The missing state is not a reporting gap. It is a definition error in the model of the work itself, and it resolves toward closure every time, because closure is the only state the system knows how to reach.
Define the state. Then define what ends the loop.
This article draws on architecture and validation work behind STDec, the AI decision workspace I am building. The product is not finished, and several of its central hypotheses remain explicitly unmeasured. That is not hidden unfinished work; it is part of the architecture: STDec is being designed to preserve the difference between what a system produced, what it proved, what it does not know, and what a user can safely act on.