---
title: "Agent Orchestration Patterns: 8 Designs for Small Teams"
description: "Compare 8 agent orchestration patterns for small teams, from sequential pipelines and claims to supervisors and handoffs, with pros, cons and setup tips."
url: https://projectify.si/blog/agent-orchestration-patterns
updated: 2026-11-13
---

# Agent Orchestration Patterns: 8 Designs for Small Teams

Published 2026-11-13 by the Projectify team · Topics: agent orchestration patterns, multi-agent coordination, AI agent workflows, Claude Code workflows, AI project management

Two Claude Code sessions pick up the same bug within a minute of each other. Each reads the file, decides the fix is obvious, and writes. The second write lands on top of the first. Neither session knows the other exists, and the diff you open twenty minutes later has a lost method, a stray import and no clue which agent did what.

That isn't a model problem. Both agents did reasonable work in isolation. The failure sits in the space between them: no ownership, no shared state, no rule about who goes first.

Agent orchestration patterns are the arrangements that close that space. Some are rigid, like a fixed pipeline with a gate after every stage. Some are loose, like agents posting findings to a shared board and picking up whatever is unclaimed. Each one trades a kind of freedom for a kind of safety.

The eight below are ordered by the failure each removes: collisions, cold starts, lost context and unclear ownership. Every one of them can run on a single shared task board, which is the point. Diagrams are cheap. A board where the second agent can see the task is already taken is what stops the double write.

If your sessions already collide, start at number two. If they open every session by re-reading the whole repo, start at number three.

## Table of Contents
- [1. Sequential Pipeline (Prompt Chaining)](#1-sequential-pipeline-prompt-chaining)
  - [Put a gate between stages](#put-a-gate-between-stages)
- [2. Concurrent Fan-Out / Fan-In (Parallelization)](#2-concurrent-fan-out-fan-in-parallelization)
  - [Split by artifact, not by question](#split-by-artifact-not-by-question)
- [3. Supervisor / Orchestrator-Workers](#3-supervisor-orchestrator-workers)
  - [Give the orchestrator a ledger, not a memory](#give-the-orchestrator-a-ledger-not-a-memory)
- [4. Hierarchical Teams](#4-hierarchical-teams)
  - [Two layers, rarely three](#two-layers-rarely-three)
- [5. Handoff (Routing and Transfer)](#5-handoff-routing-and-transfer)
  - [Transfer ownership, not the transcript](#transfer-ownership-not-the-transcript)
- [6. Group Chat / Multi-Agent Debate](#6-group-chat-multi-agent-debate)
  - [Cap the turns, then decide](#cap-the-turns-then-decide)
- [7. Blackboard (Shared Workspace)](#7-blackboard-shared-workspace)
  - [The board is the architecture](#the-board-is-the-architecture)
- [8. Evaluator-Optimizer (Maker-Checker Loop)](#8-evaluator-optimizer-maker-checker-loop)
  - [Write the checks before the generator runs](#write-the-checks-before-the-generator-runs)
- [Agent orchestration patterns at a glance](#agent-orchestration-patterns-at-a-glance)
- [Pick the Smallest Pattern That Stops Your Agents Colliding](#pick-the-smallest-pattern-that-stops-your-agents-colliding)

<a id="1-sequential-pipeline-prompt-chaining"></a>
## 1. Sequential Pipeline (Prompt Chaining)

A drafting agent writes a spec. A reviewer reads only the spec and marks what's missing. An implementer builds from the approved version and nothing else. Three sessions, one direction, no shared workspace to fight over.

Reach for this when the work already has an order. Bug fixing has one: reproduce, patch, add a regression test, open a review. Content has one: draft, fact-check, edit. Feature delivery has one: spec, implementation, test, review. The pipeline makes that order explicit and puts a checkpoint at every boundary.

**It's also the easiest pattern to debug.** Each stage has one input and one output, so when the result is wrong you point at the stage that produced it instead of reading four transcripts.

![A robot processes a document through an automated inspection gate to demonstrate successful agent orchestration workflow.](https://cdnimg.co/0d03a4e6-21c3-4c7d-8a76-8c3320cbb3a7/612adabc-fa1f-4126-ac16-c40c4db84332/agent-orchestration-patterns-automated-process.jpg)

<a id="put-a-gate-between-stages"></a>
### Put a gate between stages

The failure mode is a cascade. A hallucinated first-stage output gets carried forward and polished by every agent after it until the final answer reads confidently and is wrong. The fix is a gate that checks the output's shape before the next agent starts: does the spec list acceptance criteria, does the patch apply cleanly, do the tests exist.

- **Gate on format, not vibes:** a script that checks for required sections beats a reviewer agent asked whether it "looks good".
- **Map each stage to a status:** the chain is only visible if the board shows it, so the task moves from spec to build to review as each agent finishes.
- **Write the handoff as the next input:** the note carries the goal, the decision and the open questions, so the next agent doesn't reread the whole chat.
- **Keep stages small:** a failed stage should be retryable on its own, not a reason to restart the chain.

> A five-stage chain with no gates is one agent with four extra ways to be wrong.

<a id="2-concurrent-fan-out-fan-in-parallelization"></a>
## 2. Concurrent Fan-Out / Fan-In (Parallelization)

Say a pull request touches a payment service, a queue consumer and an email template. Three agents take three lenses: one reads for security, one for query cost, one for accessibility. None of them need each other's output, so the review lands in the time of the slowest branch instead of the sum of all three.

That's the whole promise. Split independent subtasks, run them together, merge the results. Bug triage across components works the same way, and so does an agency running four client workstreams in one afternoon.

The trap is assuming more agents means more capability. A recent [survey of 90 studies on agent architectures](https://link.springer.com/article/10.1007/s10462-025-11422-4) separates symbolic systems with persistent state from prompt-driven generative ones, and the practical conclusion is that coordination overhead, duplicated context, conflicting decisions and recovery cost can outweigh the value of specialization. Parallelism without ownership is a faster way to produce conflict.

<a id="split-by-artifact-not-by-question"></a>
### Split by artifact, not by question

Branches must never write to the same file or the same task. Split by module, by epic, by component, so every branch has an exclusive patch of ground. If two branches need the same file, you have a pipeline rather than a fan-out, and running them together buys you a merge fight.

Watch the numbers that move first: collision rate, duplicate work and stale claims. If they climb as you add agents, the fan-out is too wide.

- **Claim before you branch:** a claim is a lease on a task, and only the holder changes it. A second agent is told who holds the task and when they were last active, so it picks something else instead of overwriting.
- **Name one merge owner:** one agent or one person owns the join, and the merge result is recorded as a decision or a handoff rather than living in a chat log.
- **Cap at the number of independent subtasks:** three separate streams beat six that half-overlap.

If you're already running several sessions against one repo, [running several Claude Code agents in parallel](https://projectify.si/blog/running-several-claude-code-agents) covers the setup mechanics.

<a id="3-supervisor-orchestrator-workers"></a>
## 3. Supervisor / Orchestrator-Workers

A task is ready for design review, another is blocked on an API decision, and a third can start now. A supervisor checks the shared board, assigns the available work, then brings the results together. Workers focus on their assigned tasks; the supervisor keeps the overall work moving.

A 2025 [PwC survey of 300 senior executives](https://www.pwc.com/us/en/tech-effect/ai-analytics/ai-agent-survey.html) found that 79% said AI agents were already being adopted in their companies, while 88% expected their team or business function to increase AI-related budgets during the following 12 months because of agentic AI. As teams add agents, the coordination model matters as much as the choice of worker.

![A diagram illustrating the supervisor orchestrator-worker agent pattern for managing and coordinating AI agent tasks.](https://cdnimg.co/0d03a4e6-21c3-4c7d-8a76-8c3320cbb3a7/7d74376c-13a8-425c-beb2-448763091fe3/agent-orchestration-patterns-agent-pattern.jpg)

Magentic-One illustrates this pattern: an orchestrator directs web, file and code agents against a shared task ledger, giving workers a record of what has already been covered.

<a id="give-the-orchestrator-a-ledger-not-a-memory"></a>
### Give the orchestrator a ledger, not a memory

A supervisor that holds the plan only in its context window can lose track as the session grows. Put assignments and status on a board so the state survives between sessions and workers.

- **Keep assignment decisions with the orchestrator:** it chooses what needs doing and who should do it. Each worker gets the task details it needs to act.
- **Ask for structured results:** have workers report status, artifacts and open questions. That gives the supervisor concrete inputs to review and combine.
- **Dispatch work that is ready:** a ranked queue of unblocked, available tasks helps the supervisor assign work without duplicating active assignments.

Projectify's Orchestrator reads across projects to see what is ready, blocked or waiting for review, then sends the right chat to work. On the board, a ranked Start next queue gives people and agents available work to pull. A claim makes ownership visible: if another agent already holds the task, the second sees who claimed it and when they were last active. The supervisor can assign with a shared view of both status and ownership.

The walkthrough below shows the delegation loop in motion.

<iframe width="100%" style="aspect-ratio: 16 / 9;" src="https://www.youtube.com/embed/5kwWnMlH1VU" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen></iframe>

<a id="4-hierarchical-teams"></a>
## 4. Hierarchical Teams

A product lead agent splits an epic into frontend, backend and QA. Each of those has a lead agent that splits the work again among specialists. Nobody at the top tracks individual commits, and nobody at the bottom needs the full product context.

Hierarchy is what you reach for when one supervisor's queue is too long to reason about, because it keeps each agent's context small. A 2026 [survey of LLM-based multi-agent orchestration](https://econpapers.repec.org/article/gamjftint/v_3a18_3ay_3a2026_3ai_3a6_3ap_3a326-_3ad_3a1967830.htm) organizes the field around three topologies, centralized, decentralized and hierarchical, plus a second dimension for whether control is dynamic and adaptive. Its assessment is that hierarchy can balance scale with control, while a purely centralized coordinator gives global visibility and policy enforcement at the cost of a bottleneck and a single point of failure.

![A hand-drawn organizational chart showing a leader managing two teams with multiple direct report roles.](https://cdnimg.co/0d03a4e6-21c3-4c7d-8a76-8c3320cbb3a7/30f159cd-74f1-4bd9-9912-7a24e33def89/agent-orchestration-patterns-organizational-chart.jpg)

The cost is latency and indirection. Every layer adds a hop, and a message travelling up and back down loses detail at each step.

<a id="two-layers-rarely-three"></a>
### Two layers, rarely three

Most small teams should stop at two: a lead and its specialists. A third layer usually exists to route messages nobody reads, and it doubles the number of places a handoff can go missing.

> **Practical rule:** if a layer's only job is to forward work, delete the layer and let the specialist report upward directly.

- **Map team boundaries to projects or epics:** each team gets its own knowledge shelf, so its agents read their own brief rather than the whole company's.
- **Require a written handoff at the end of each cycle:** the team lead records what's done and what's next before delegating again.
- **Constrain permissions per team:** an agent should only be able to change tasks inside its own project, which is what makes the boundary real.

<a id="5-handoff-routing-and-transfer"></a>
## 5. Handoff (Routing and Transfer)

Routing differs from delegation. In a handoff, control passes completely: the receiving agent owns the work and doesn't report back to the sender. Triage is the classic case. A support agent reads the request, decides it's a billing problem, and transfers to the billing agent with the context attached.

OpenAI's Swarm popularized the explicit handoff as a primitive, and the Agents SDK carries it forward. The same move shows up in any workflow where ownership changes as the task evolves, from support to review to escalation.

The reason to be careful is trust. Harvard Business Review Analytic Services [surveyed 603 technology decision-makers](https://www.workato.com/full-reports/2025-hbr-enterprise-agentic-ai) and found 86% planned to increase agentic-AI investment over the following two years, while only 6% trusted AI agents to autonomously manage core end-to-end business processes such as source-to-pay or hire-to-retire. Handoffs are where that gap is won or lost, because each transfer is a point where a person stops being able to see the thread.

<a id="transfer-ownership-not-the-transcript"></a>
### Transfer ownership, not the transcript

A handoff note isn't a summary of the conversation. It's the minimum a competent stranger needs: the goal, what's been done, what's still open, and which tasks were touched. Longer notes get skimmed.

- **Limit the allowed targets:** each agent should hand off to two or three named agents, not to any agent. Open routing produces loops where two agents bounce a task back and forth.
- **Record why the transfer happened:** an activity feed showing "routed to billing, duplicate charge" tells you more than one showing "status changed".
- **Escalate when no target fits:** unclear cases go to a person rather than to a general-purpose agent that will guess.

Sessions in Projectify end with a handoff of exactly that shape, so the next session starts from the note instead of a cold read. If you're writing your own template, [the handoff that ends every working session](https://projectify.si/blog/the-handoff) is the format to copy.

<a id="6-group-chat-multi-agent-debate"></a>
## 6. Group Chat / Multi-Agent Debate

A designer agent, an engineer agent and a security reviewer agent read the same spec. The designer objects to the empty state, the engineer flags the missing index, the security reviewer asks why the endpoint returns the full record. None of them would have caught the other two's issue alone.

Group chat puts several roles into one shared conversation, with a manager or a selection function deciding who speaks next. Microsoft's AutoGen GroupChat is the reference version: agents take turns, critique each other's proposals, and converge.

The value is perspective diversity, not consensus. A panel that agrees in round one has told you the spec is easy, or that all three agents share the same blind spot.

<a id="cap-the-turns-then-decide"></a>
### Cap the turns, then decide

Debate has no natural stopping point, and an unbounded loop burns tokens while producing longer answers rather than better ones. Set a hard turn limit and a condition for stopping early, such as two rounds without a new objection.

> Two rounds catch most real disagreements. Five rounds mostly restate them with more confidence.

- **Keep the chatter short:** agents post a few lines in the project chat room when they start, touch something shared, or get blocked. Long arguments belong in a decision record, not in the room.
- **One agent argues against the group:** a named dissenter whose job is to attack the emerging conclusion is the cheapest defense against three agents agreeing for the wrong reason.
- **End in a decision a person accepts:** the panel produces a short record with the context, the options and the consequences. The reasoning then survives the session.

That last point matters more than the debate itself. An argument nobody recorded has to be had again next week.

<a id="7-blackboard-shared-workspace"></a>
## 7. Blackboard (Shared Workspace)

The blackboard pattern skips conversation entirely. Agents read from and write to one shared store holding the state of the problem, and a control mechanism decides who acts next. Any agent with something useful posts it.

Hearsay-II, the speech-understanding system from the 1970s, is the original, and the shape has aged well. Language models read structured state competently and remember long conversations badly. Picture a shared board: one agent posts the failing test, another posts the likely cause, a third posts the patch. Everyone can see where the task stands without a single message passing between them.

<a id="the-board-is-the-architecture"></a>
### The board is the architecture

If the board is the shared state, its rules are the coordination design. Every write needs attribution to a person and an agent, every claim needs an expiry, and every item needs a status an agent can parse.

Auditability gets decided here too. A 2026 [survey of emergent risk in multi-agent systems](https://link.springer.com/chapter/10.1007/978-981-92-1468-6_3?error=cookies_not_supported&code=64e1b761-9963-4dab-9330-62dbfed3c1b8) reports risks including bias amplification, adversarial vulnerability, data leakage and decision opacity, and finds that audit tools, benchmarks and orchestration frameworks remain fragmented, with no unified evaluation ecosystem for cross-agent risk in multi-turn settings. It also cites an enterprise study of 202 Global 2000 organizations that hits a coordination complexity ceiling at roughly five agents, with 31% relying on custom-built orchestration and 26% on proprietary agent-to-agent protocols.

Five agents is a board, not a platform. That's the argument for getting the board right before you outgrow it.

- **Use leases, not locks:** a claim that expires after the holder goes quiet recovers from a crashed agent without anyone manually freeing a task.
- **Separate state from reasoning:** structured fields for status, owner and blocked-by; free text for the argument.
- **Read the feed:** conflicting or stale writes surface there first, usually as two agents describing the same task in incompatible terms.

<a id="8-evaluator-optimizer-maker-checker-loop"></a>
## 8. Evaluator-Optimizer (Maker-Checker Loop)

One agent generates. A second evaluates against explicit criteria and sends back specific failures. The loop runs until the output passes or the iteration cap is reached.

This works when the criteria are checkable: tests that must pass, a linter that must run clean, a style guide with named rules. It fails when the evaluator is asked for a vibe. "Does this look right" produces a rubber stamp with extra tokens attached.

![Two cute cartoon robot characters collaborating on a document with a magnifying glass and a pen.](https://cdnimg.co/0d03a4e6-21c3-4c7d-8a76-8c3320cbb3a7/d3c99916-fab2-41ea-a627-5135c8b01090/agent-orchestration-patterns-robot-collaboration.jpg)

A concrete shape: an agent writes a change, a reviewer agent runs the test suite and names the failures, and the generator fixes exactly those. The generator never sees the reviewer's praise, only the distance between the output and the criteria.

<a id="write-the-checks-before-the-generator-runs"></a>
### Write the checks before the generator runs

Acceptance criteria written after the fact get bent to fit whatever was produced. Put them on the task first, as runnable checks wherever you can, so the evaluator has something to point at.

- **Set an iteration cap and escalate:** three attempts is usually enough. After that, the task goes to a person with the failures attached, because a fourth attempt rarely finds what three missed.
- **Separate the claims:** the generator and the evaluator work on different claims, so one agent can't approve its own work by editing the task.
- **Turn repeated feedback into rules:** if the same objection appears in three reviews, it belongs in the project rules, where every future agent reads it before starting.

Code review is the most common place this pays off, and this [review loop that catches what a single agent misses](https://projectify.si/blog/ai-code-review) is a good template to start from.

<a id="agent-orchestration-patterns-at-a-glance"></a>
## Agent orchestration patterns at a glance

| Item | Control | Best for | Main risk |
|---|---|---|---|
| Sequential Pipeline (Prompt Chaining) | Fixed sequence with optional gates | Defined workflows with clear stages | Early errors propagate; latency accumulates |
| Concurrent Fan-Out / Fan-In (Parallelization) | Coordinator dispatches parallel tasks and merges results | Independent work that benefits from faster completion | Conflicting outputs, higher cost, or branch collisions |
| Supervisor / Orchestrator-Workers | Central agent dynamically delegates and synthesizes | Complex, open-ended tasks needing specialist work | Orchestrator becomes a bottleneck or single point of failure |
| Hierarchical Teams | Multiple layers of team leads and workers | Large systems with bounded domains and responsibilities | Delegation overhead and detail lost in summaries |
| Handoff (Routing and Transfer) | Explicit ownership transfer based on task needs | Triage and workflows where specialist ownership changes | Routing errors, context loss, or agent ping-pong |
| Group Chat / Multi-Agent Debate | Shared discussion with speaker selection and stopping rules | Review, critique, and problems needing diverse perspectives | High cost, groupthink, or failure to converge |
| Blackboard (Shared Workspace) | Agents read and update shared state under a scheduler | Work requiring durable, inspectable shared context | Conflicting writes or stale, inconsistent state |
| Evaluator-Optimizer (Maker-Checker Loop) | Generator iterates on evaluator feedback against criteria | Outputs that can be checked against clear standards | Costly loops that fail to converge |

<a id="pick-the-smallest-pattern-that-stops-your-agents-colliding"></a>
## Pick the Smallest Pattern That Stops Your Agents Colliding

Start with the failure that's costing you most, not with the pattern that sounds most advanced. If sessions overwrite each other, you don't need a supervisor. You need claims on tasks and a rule that only the holder writes. If every session starts cold, a briefing and a handoff note will do more for you than a hierarchy ever will.

The order I'd add them in is roughly this. A **sequential pipeline** first, when the work already has an order and you want the checkpoints. A **fan-out** next, once you can see which subtasks are independent. A **supervisor** when a single queue no longer fits in one person's head, and **hierarchy** only when a single supervisor's context stops fitting. Reach for a **blackboard** when agents need shared state more than conversation, and an **evaluator-optimizer** loop once you can write down the checks.

Everything past the second pattern carries overhead. Coordination costs tokens, latency and one more thing to debug at 11pm. Adding agents to a task that one agent handled fine is a downgrade dressed as sophistication.

Measure the right things and the choice gets obvious. Collision rate tells you whether ownership is clear. Duplicate work tells you whether the queue is visible. Stale claims tell you whether leases expire. Escalation rate tells you whether the autonomy you've granted is earned. A handoff that's missing context shows up as a session that redoes finished work an hour later.

Projectify puts those mechanics on one board underneath whichever pattern you pick. An agent claims a task and holds a lease on it, pulls the next free and unblocked item from a ranked queue, starts from a briefing with the project rules and the last handoff, and ends by writing the handoff for whoever comes next. Every write carries the person and the agent behind it, so the audit trail exists whether or not you remembered to build one.

The pattern matters less than the ownership rule underneath it. Two agents that can see who holds a task will almost never collide, whatever shape you drew on the whiteboard. Draw less, claim more.

---

Projectify is a project board where people and their AI agents work the same tasks without overwriting each other. Claims tell a second session who already holds the work, Start next keeps every agent pulling from free and unblocked tasks, and a handoff at the end of each session means the next one begins with what the last learned. Connect Claude Code and see the difference by your first handoff at [Projectify](https://projectify.si).
