Done Is a Factory Decision

A person eventually gets tired, runs out of calendar, or decides the remaining flaw is not worth another hour. An agent has no equivalent instinct. It can rewrite the function, rerun the test, adjust the plan, and try again for as long as the system keeps returning the work. Persistence is useful. Without a stopping rule, it is also indistinguishable from waste.

This is why an agent loop is not a strategy by itself. A loop only says that output can return as input. It does not say whether the next cycle gets closer to the result, whether the result is still worth its cost, or whether the destination was possible in the first place. Those decisions live outside the model.

The uncomfortable part is that teams often have no clean definition of done for people either. They rely on a reviewer recognizing quality, a deadline forcing a release, or somebody senior deciding that the argument is over. Put an agent into that system and the missing decision becomes visible. The machine cannot execute a standard the organization never made explicit.

A test does more than approve the final change. It shapes every attempt that comes before approval. If the factory rewards a passing check, the agent will search for a path to that check. When the check is a faithful expression of the requirement, the search moves toward useful software. When it is a weak proxy, the loop can improve its score while moving away from the thing the customer needed.

That failure is easy to miss because the evidence looks disciplined. The agent made a change, observed a result, and responded to feedback. The loop converged. It simply converged on the wrong target. More retries make that problem worse because each cycle teaches the builder how to satisfy the proxy more precisely.

Independent proof matters here. The builder can propose tests and repair what fails, but it cannot own the final interpretation of success. Acceptance has to trace back to the promised behavior and run somewhere the builder did not choose. Otherwise generation, evaluation, and authority collapse into one confident voice.

A healthy loop can explain what became different after each turn. A failing case got smaller. A missing contract became available. An assumption was disproved. A local edit preserved the parts that already worked. The state changed in a way that reduced uncertainty, and the next action follows from that change.

A weak loop only changes the artifact. It rewrites the same area, samples another answer, or adds more explanation while the evidence stays flat. Activity continues, but the factory has learned nothing. That is the point where persistence should lose authority. The work needs a different tool, a narrower specification, a human decision, or a clean rejection.

So record more than attempts. Record the state the agent observed, the exact action it took, the evidence that came back, and the reason another cycle is justified. That trace lets the factory detect repetition mechanically. It also gives a person something better than a long transcript when judgment is actually required.

Every route needs at least three exits: accepted, rejected, and escalated. Accepted means the promised behavior survived the required proof. Rejected means the route reached a known boundary and should not spend another attempt. Escalated means the machinery found a decision it is not authorized to make. These are operating states, not moods.

Cost belongs in that decision, but a budget alone is too blunt. Running out of tokens does not tell you whether the result was nearly complete, fundamentally impossible, or aimed at the wrong target. Pair the budget with evidence of progress. A consequential task may deserve another expensive cycle when the uncertainty is shrinking. A cheap task should stop early when every pass returns the same failure in different words.

Humans set these boundaries because the consequences belong to the business. They decide which defect is tolerable, which risk requires proof, and which outcome no longer justifies the search. The factory gives those judgments mechanical force. It should not wait for somebody to notice a runaway process after the bill arrives.

Start with the acceptance condition before you start the agent. Name the behavior that must hold, the evidence that can prove it, the surfaces the builder may change, and the cost or attempt boundary for the route. Then define what information earns another pass. If you cannot do that, you do not have an autonomous task yet. You have an open-ended request with a meter attached.

Our position is that factories will replace people in repeatable delivery work. That only works when the factory also absorbs the decisions people used to make by habit: when to retry, when to reject, when to ask, and when to ship. Leaving those decisions in a review queue preserves human coordination as the runtime and calls the result automation.

The model is not the hard part. Models can keep producing options. The hard part is building a system that knows which option changed the state, which proof deserves authority, and when another attempt has lost the right to run. Done is not something the agent discovers inside its own output. Done is a decision the factory was built to enforce.