The Handoff Is the System

Most teams evaluate an agent the way they evaluated a person doing one job. Did the researcher find useful context? Did the planner produce a plausible plan? Did the builder make the tests pass? Did the reviewer spot a defect? Those are reasonable questions, and they miss the factory. A line is not the sum of its stations. It is the behavior of the transfers between them.

One agent finishes with a confident summary. The next treats that summary as fact. A planner quietly converts an assumption into a requirement. A builder satisfies the requirement exactly. A verifier proves the wrong behavior with immaculate evidence. Every station can look competent while the line compounds one unmarked guess into shipped software.

That is why adding a better model rarely repairs the system. The model may improve each local answer while leaving the transfer unchanged. You get cleaner prose, faster code, and the same hidden assumption moving downstream with more authority than before.

Human teams survive vague handoffs by interrupting each other. Someone notices that a ticket sounds odd, remembers the meeting where the edge case came up, and asks a question. That repair work is expensive and inconsistent, but it hides weak interfaces. Agent fleets remove the social friction and, with it, the accidental rescue. They accept the artifact they were given and keep moving.

A factory handoff must say what arrived, what is known, what remains uncertain, and what the receiving stage is allowed to do about it. Evidence must travel with the claim it supports. Assumptions must stay labeled as assumptions. Rejected alternatives must remain visible long enough that the next stage does not rediscover and accidentally choose them.

The format matters less than the enforcement. A beautiful template that an agent can leave half empty is documentation. A contract that rejects an artifact without the required fields is machinery. If uncertainty is allowed, define how it is represented. If it is not allowed, stop the line instead of giving the next agent permission to guess.

Organizations trained on human delivery often treat a stopped line as failure. They reward motion, so every participant learns to smooth over ambiguity and keep the work moving. That instinct is destructive at machine speed. An agent that politely completes an underspecified task can create more waste in minutes than a blocked ticket created in days.

A productive factory refuses bad inventory early. The planning stage rejects a request with no decided outcome. The build stage rejects a plan whose acceptance conditions contradict each other. The verification stage rejects evidence produced only under conditions chosen by the builder. Each refusal should name the missing decision and route it to the person who owns the consequence.

This is not putting a person back into every step. It is concentrating human judgment where judgment is actually required. People choose the destination, settle genuine tradeoffs, and decide what risk the business will accept. The machinery should handle everything repeatable around those decisions, including the discipline to wait when a decision has not been made.

A handoff is trustworthy only when the receiver can challenge it. If the builder chooses the test, the environment, and the definition of success, the evidence proves that the builder can satisfy its own story. The next stage needs independent conditions: a clean environment, an adversarial check, a policy the author cannot edit, or an observable outcome outside the implementation path.

Independence does not require a grand review committee. It requires separation of authority. The agent that changes the system should not be able to weaken the gate that approves the change. The artifact should carry enough provenance to reconstruct what happened. Exceptions should be explicit, owned, and durable instead of buried in a chat transcript that disappears from the next run.

That boundary is where confidence becomes evidence. Without it, a fleet is a chain of agents agreeing with one another. With it, each stage earns the right to feed the next.

Before you add another agent, inspect one real piece of work at every transfer. What does the receiving stage assume? Which facts can it verify? What happens when the artifact is incomplete? Who owns the decision needed to unblock it? If the answer is that the agent will figure it out, you have found an uncontrolled production decision.

Then turn the answers into interfaces that bite. Validate the artifact shape. Attach evidence to claims. Preserve uncertainty instead of laundering it into certainty. Give every stage narrow authority and a clear refusal path. Measure how often work is rejected at each boundary and fix the upstream mechanism rather than coaching the downstream agent to cope harder.

Our position is blunt: the companies that scale agent-run delivery will not win because their individual agents look smarter in a demo. They will win because their factories make bad work difficult to pass forward. The stations create output. The handoffs decide whether that output becomes a system or just a faster pile of mistakes.