Two AI agents can be worse than one

The intuitive case for multi-agent work is easy to state: if one capable AI agent can solve a hard problem, two should be able to divide it, challenge each other and finish sooner.

That is not evidence that multi-agent systems fail. It isolates a failure that grows more important as capability rises: every additional solver introduces another private state, plan, set of assumptions and handoff.

Those are coordination failures, not failures to exchange messages. Communication transfers symbols; coordination aligns action over time. It needs a shared account of who promised what, which state each participant used, what changed, which dependency is blocked, whether the promise was kept, and how separate outputs become one verified result.

Natural language negotiates well and records badly. "I'll avoid that file" does not lock the file. "My part is done" does not prove that integration tests pass. "We agreed on the interface" does not establish that both AI agents implemented the same version. An articulate status update can leave every operational fact unresolved, which is why the benchmark's sharpest result is not that AI agents write bad code — it is that several locally plausible actions can produce a globally broken outcome while the transcript still reads as teamwork.

The standard answer is to add a human. The phrase sounds like judgment, accountability and control, and it leaves the operating questions open: which person, at what point, with access to what evidence, with authority to stop which action, and accountable for which consequence.

People are not durable coordination layers. We move between meetings, chats, documents, dashboards and emergencies; we omit context that feels obvious; we change a priority in one channel and assume the rest of the system heard it; we sometimes accept a plausible summary without opening the artifact underneath. Even when a decision is remembered, its reasoning often is not.

The ecosystem is building useful layers. Agent2Agent defines how a client AI agent discovers a remote one, creates a stateful task, exchanges messages and receives artifacts. The Model Context Protocol standardizes connections between AI applications and external tools or data, and its sampling specification recommends that a person be able to inspect and deny requests. Stanford's Human Context Protocol proposes portable, user-governed preferences with scoped access and revocation.

Each reduces bespoke integration work. None of them decides whether the work was worth doing, which trade-off the organization accepted, whether two outputs are consistent and built on the same assumptions, or who may authorize the combined result. Transport and interoperability are necessary. They are not management, accountability, or a work contract.

Most teams still write work as though every participant were the same kind of worker. A ticket has a title, a paragraph of desired behaviour, maybe acceptance criteria, and some links. People fill the gaps from organizational memory and conversation; AI agents fill them by statistical inference. Those are not the same operation.

• A person needs to know why the work matters, what changed commercially or politically, which trade-offs are legitimate, who owns the decision, and when the premise itself should be challenged.
• An executing AI agent needs explicit input state, versions, dependencies, permitted tools, scope boundaries, prohibited actions, required evidence, and a condition it can test.
• A verifier needs the claim under test and the evidence required to settle it.
• Whoever holds the decision right needs the verified result, the residual risks, the rollback conditions, and the choices available.

Give all four the same prose ticket and the mismatch is predictable: the person gets too little meaning, the AI agent too much ambiguity, and the reviewer an artifact with no contract to judge it against. One task, four interfaces.

A coordination layer needs to retain the life of the work, not just its definition.

• Every delegation creates a visible commitment: owner, promised artifact, dependency, deadline or triggering event, evidence, and escalation condition.
• Every material change updates shared state instead of living in one conversation.
• Every handoff carries the versions used and the uncertainty still open.
• Automated controls may verify criteria and a stated policy may qualify a low-risk action, but accepting residual risk stays with the named decision-right holder.

This changes what chat is for. Chat becomes where participants negotiate intent and exceptions, and stops being the only place the organization keeps operational truth. The same principle governs parallelism: parallel work begins where outputs can be isolated or dependencies are explicit, integration order and conflict ownership are settled before volume arrives, and an AI agent announcing completion is not the same event as the system verifying the promised artifact against the agreed contract.

8Hats Lab's working answer is that the unit of design is the human–AI team — the smallest combination of people, AI agents, tools, context and controls that can carry work from intent through verification, authorization, use and outcome measurement — and that the task definition inside it should hold synchronized views rather than one prose ticket: a brief that explains purpose and trade-offs, an execution contract that fixes state, tools, scope, evidence and a checkable completion condition, and a verification view naming the claim under test, the residual risks and whoever decides what happens next.

Those three are not separate documents permitted to drift. If the desired outcome changes, the execution contract is stale. If an AI agent discovers a blocking fact, the brief has to expose the changed premise. If verification needs more evidence, the work reopens without pretending execution never happened.

This is an 8Hats proposal and not a validated result. It has not been tested against a controlled comparison, and it is deliberately not offered here as a named standard: the glossary has no entry for it yet, and a term introduced by an essay is a term the organization has not agreed to.