Six ways to coordinate AI agents, and the controls each one needs

The supervisor pattern is the usual starting point for good reason: the plan lives in one place, budgets are enforced in one place and there is one trace to start from when something fails. It corresponds to what Anthropic's agent guidance calls orchestrator-workers, suited to tasks whose sub-tasks cannot be predicted in advance¹. Its weakness is the supervisor's own context, which fills with every worker's output as the task grows.

Hierarchical teams add supervisors of supervisors: a top-level planner hands whole workstreams to team leads, each managing its own workers. The extra layer pays off when workstreams are large, independent and need different expertise, such as the legal, financial and technical strands of a due diligence review. Every level adds a round of summarizing that loses detail, so require team leads to pass up references to the evidence, not only conclusions.

Pipelines are the most predictable pattern because the order never changes; Anthropic's guidance calls the same idea prompt chaining, with programmatic checks between steps¹. Use them when every task has the same shape, such as processing one standard document type. They handle tasks whose next step depends on what was found poorly, because every branch has to be designed in advance.

The hard part is fan-in. Results arrive at different times, some agents time out and some findings contradict others. Decide in advance whether the aggregator waits for every agent or proceeds after a quorum or deadline, and mark missing parts in the output. Record conflicting findings with their sources for the reviewer or a person to resolve; a vote between agents sharing a model mostly measures their shared assumptions.

In a blackboard design, agents do not message each other directly. They read from and write to a shared, structured workspace, and a controller decides which agent acts next based on what the board contains. It suits problems where many specialists contribute partial results in an unpredictable order, such as assembling a case file from several types of evidence.

The risk is concurrent writes. Give every entry a named owner and a version, let only the owning role change it, and have other roles add linked annotations instead of editing. An append-only log of board changes lets you replay a run and see which agent changed what.

A critique loop pairs a producer with a critic: one drafts, the other evaluates against stated criteria and returns specific issues, and the producer revises. Anthropic describes this as the evaluator-optimizer pattern, useful when clear criteria exist and iteration measurably improves the result¹. Debate variants put two agents on opposing sides and ask a third to judge between them.

Loops need hard limits. Cap the number of iterations, and stop when a revision no longer changes the critic's verdict or the critic starts repeating itself. Give the critic the acceptance criteria and evidence rather than the producer's reasoning, and where possible a different model, so it is not simply agreeing with a familiar style of argument.

Patterns describe how agents coordinate; protocols describe how they communicate when they were not built together. The Agent2Agent (A2A) protocol, originally developed by Google and now hosted by the Linux Foundation, is an open standard for agents to discover one another and exchange tasks across frameworks and vendors; the Linux Foundation called its version 1.0 the first stable specification in April 2026². It complements the Model Context Protocol, which connects an agent to tools and data rather than to other agents.

A protocol solves transport and discovery, not trust. Agents connected over A2A still need task contracts, scoped authority and independent review, and an agent run by another organization should be treated as untrusted input until its outputs are checked. Confirm the current specification on the project's own site before building on it.