Skip to content
Inspired by FrustrationThirty of us wrote this. One of him read it.

Running agents

Multi-Agent Orchestration Patterns That Don't Collapse Under Load

Four multi-agent orchestration patterns plus a dated, reproducible single-versus-parallel code-synthesis experiment with task-level evidence.

ShareXLI
Four-panel diagram of multi-agent orchestration patterns — handoff queue, fleet broker, lane claim and contract publish — each showing its operator, workers, result path and failure path.

TL;DR — Multi-agent orchestration patterns need evidence at the task boundary. In our October 21, 2026 synthesis experiment, single and parallel agents passed every acceptance check; the single-agent condition finished sooner in both small matched blocks. This does not establish a general winner.

Single agent versus parallel agents: the measured experiment

We gave real GPT-6.1-sol agents, all at medium reasoning effort, the same owned JavaScript requirements. One agent solved the whole pack; the parallel condition gave one task to each of three fresh agents. A lane means the task one agent owns. The tasks normalized tags, selected a page of items, and removed sensitive header fields. These were synthetic functions, with no customer code or production access.

The task-level results and exact prompts contain the generated sources, host timestamps, final agent replies and check outcomes. The method and task pack and acceptance replay script let you inspect what counted as done. The following numbers come from that result file, rounded to milliseconds.

BlockAgent conditionAgent callsAccepted tasksFailed tasksRepair redispatchesElapsed seconds
1Single13/30019.753
1Parallel33/30022.165
2Parallel33/30026.908
2Single13/30018.901

Each condition faced the same 18 deterministic cases, including invalid inputs and input-mutation checks. A task was accepted only when all its cases passed. We fixed the requirements and checks before dispatch, reversed condition order in the second block, and prohibited repair redispatches. All 12 task outcomes passed. No failed submission was discarded. Internal model or tool retries were not instrumented; zero repair redispatches does not mean zero internal retries.

Elapsed time starts at the coordinator's host timestamp before dispatch and ends at the latest submission file's host modification time. It includes dispatch, agent startup, prompt reading, synthesis and the submission write. It excludes acceptance replay, human review and preparing this experiment. Parallel dispatch is staggered by the coordinator; that overhead stays in the measurement. The machine was also doing other work. Provider queueing, cache state and host load were not controlled.

Actual billed cost and human review minutes are unmeasured, stored as null. There is no invoice, token receipt or timed human review behind this run. Automated acceptance is not human review. Agent-call counts are a workload measure, not a dollar estimate. A deployment pilot should record reviewer start/stop times and attributable usage receipts before comparing cost per accepted task; missing receipts stay unknown.

The observed result is narrow: parallel dispatch took longer on this tiny pack in both blocks. We cannot attribute the difference to reasoning speed or predict results for a larger backlog. The workload contains no shared-file conflicts, integration, browser checks or recovery after a failed task. The harness separately rejects a deliberately wrong solution and a nonterminating solution; those are test controls, not model failures. More agents. Occasionally more overhead.

These outputs are built and verified fixtures, not changes merged into a customer application. Publication still requires independent review and deployment. To test your own orchestration, discuss a bounded pilot using the same acceptance rubric and your actual integration work. Fleet economics covers the broader accounting question; this sample supplies no billed-cost comparison.

Historical pattern discussion: July 2026

The original discussion below describes the operating setup at publication. Its fleet volumes, service names and merge behavior were not remeasured by the October experiment and should not be read as current infrastructure verification.

Most multi-agent writing is too clean. It shows boxes, arrows, and a perfect handoff between agents that never panic, overwrite each other, or flood CI. That is the surface. The interesting part is what happens when thirty coding agents touch the same product and the operator still expects merged code, not theater.

This is a field report from inside a one-operator AI studio running roughly 30 concurrent coding agents across Claude Code, Cursor, Codex, and Copilot. The current operating numbers are not aspirational: 55 merged PRs per day on average, 66 per day over the last 7 days, a peak of 111 on 2026-05-21, and a median queue-to-merge time of 5 minutes.

The pattern library below came from that pressure. Four names matter: Handoff-Queue, Fleet-Broker, Lane-Claim, and Contract-Publish. They are not framework names. They are operating shapes. The architecture is what makes them honest.

Anthropic’s Building Effective Agents gives the useful framing: workflows follow predefined code paths, while agents dynamically decide how to use tools and proceed. Real AI agent development needs both. The trick is putting each one in the right lane.

What multi-agent orchestration actually means

Multi-agent orchestration is the control layer that coordinates multiple agents, tools, queues, contracts, and ship gates so work can move without collisions. It is not just “many agents.” A pile of agents is a swarm. Orchestration is the set of constraints that turns that swarm into throughput.

A swarm is useful when exploration matters. Production work has a different shape. Somebody has to claim scope, publish expected outputs, avoid duplicate edits, pass CI, merge safely, and leave audit behind.

That is why my default stack is not model plus prompt. It is Next.js + Supabase + Fly + Cloudflare + Infisical + MCP + Claude Code agent fleet, with branch protection, ship gates, evals, and audit as the governance baseline. Agents can be creative inside the fence. They do not get to move the fence.

One operator orchestrating ~30 parallel coding agents that ship ~55 merged PRs a day The fleet these patterns come from: one operator, ~30 parallel agents, ~55 merged PRs a day.

Pattern 1: Handoff-Queue

Definition

Handoff-Queue moves work between agents through a durable queue instead of direct agent-to-agent chatter. One agent finishes a bounded unit, writes the next task as a queue item, and exits. Another agent picks it up later with fresh context, clear inputs, and a defined acceptance check.

The point is boring by design. There is no “can you take a look?” floating inside a chat thread. There is a queued job with a payload, owner, status, retry count, and done condition.

Signature call graph

operator
  -> queue.create(task_contract)
  -> agent.pick_next(lane)
  -> agent.execute(repo_context, task_contract)
  -> ci_gate.verify()
  -> queue.complete() or queue.retry(reason)

When to use it

Use Handoff-Queue when the work is sequential, stateful, or easy to lose between sessions. It fits code cleanup, migration batches, bug triage, QA follow-up, dependency upgrades, and any work where the next step depends on the previous step being actually finished.

AppHandoff is the cleanest public artifact here. It is the agent-orchestration MCP server that finishes the Lovable 80%. Inspired by frustration. I mean that literally. Lovable can get a product very far, but the last 20% needs repo structure, build discipline, deployment wiring, and repeated cleanup.

That is where what is an MCP server stops being glossary content and becomes infrastructure. MCP gives agents tool access through a consistent protocol. The queue gives that access a work rhythm.

Failure mode

The main failure mode is queue rot. Agents keep adding tasks faster than the fleet can close them, and the queue becomes a junk drawer. The second failure mode is vague completion. If a queued task says “improve auth,” nobody knows when it is done.

My rule: every queued task needs an acceptance test, a file or route boundary, and a reason it exists. If I can't defend it in a sales call, it doesn't go on the page. The same rule applies to queues.

Code-level signal

You want explicit statuses, not vibes: queued, claimed, running, blocked, failed, ready_for_review, and merged. You also want retry limits, idempotent handlers, and the ability to replay a task without corrupting state.

Pattern 2: Fleet-Broker

Definition

Fleet-Broker routes work to the right execution lane based on capacity, cost, tool access, and risk. The broker does not do the work. It assigns the work.

This matters once you stop pretending all agents are equal. Claude Code, Cursor, Codex, and Copilot do not behave the same. Some are better for repo-wide reasoning. Some are better for isolated patches. Some should touch infra. Some should never touch deploy code without a tighter gate.

Signature call graph

operator or queue
  -> broker.classify(task)
  -> broker.select(agent_type, runner_size, repo_lane)
  -> agent.execute()
  -> broker.observe(result, cost, duration, failure)
  -> broker.adjust(next_assignment)

Business judgment picks the bet. The swarm is the engine.

When to use it

Use Fleet-Broker when you have more tasks than one agent can process and different task classes need different execution environments. This is the production shape behind a coding fleet.

In my world, infra-gha-runners-fly matters here. It is the TeamK2K self-hosted GitHub Actions runner fleet on Fly.io. The work is not only “agent writes code.” The work includes deciding where CI runs, when a just-in-time runner should exist, and how the system avoids wasting compute.

The runner dispatch layer uses fly-gha-status and fly-gha-medium JIT runner dispatch. That pairs with 63 reusable composite GitHub Actions shared across the fleet. Receipts, not claims. When a pattern runs every day, repeated YAML and hand-built one-offs become operational debt.

Failure mode

The failure mode is broker blindness. The broker keeps assigning tasks based on old assumptions. Maybe a runner pool is slow. Maybe one model is failing a class of refactors. Maybe CI is red for reasons unrelated to the current branch.

The second failure mode is too much cleverness. A broker that constantly reclassifies work can create churn. Agents start tasks, abandon them, reassign them, and produce more coordination overhead than useful work.

Code-level signal

Look for routing metadata stored with the task: task class, repo, lane, model or agent family, runner class, retry reason, and final outcome. You also want queue-to-merge, queue-to-first-run, CI duration, failure class, and retry count. Every number below is measured, not aspirational.

Pattern 3: Lane-Claim

Definition

Lane-Claim prevents agent collisions by making agents claim a bounded lane before they edit. A lane can be a route, feature area, package, migration file, test suite, or branch family. The claim says: this agent owns this slice for this run.

This is the simplest answer to “how do you prevent agent collisions?” You do not hope agents behave. You make collision impossible or obvious.

Signature call graph

agent.request_scope(task)
  -> lane_registry.check(scope)
  -> lane_registry.claim(scope, ttl, branch)
  -> agent.edit_within(scope)
  -> ci_gate.verify(scope)
  -> lane_registry.release(scope)

When to use it

Use Lane-Claim for codebases with parallel feature work. It is especially useful in Next.js apps where agents can otherwise collide across routes, shared components, generated types, and Supabase migrations.

ContextCapture is a good example. Lovable shipped as a versioned npm-style artifact into a Next.js parent. Two repos, one product. Without explicit lanes, an agent can “fix” the parent integration while another changes the artifact contract. Both are locally reasonable. Together, they break the product.

Lane-Claim also matters in Spark Central Hub, the Lovable + Claude Code co-edited repo behind leadingmomentum.lovable.app. Co-editing only works when ownership is visible. Otherwise, the human, Lovable, and coding agents all believe they are helping while quietly undoing each other.

Failure mode

The main failure mode is stale locks. An agent claims a lane, crashes, and leaves the system blocked. That is why lane claims need a time-to-live and a visible owner. The second failure mode is oversized lanes. If one claim covers src/, the system is safe but useless.

The art is choosing lane size. Too small, and agents still collide through shared dependencies. Too large, and throughput drops. For product code, I usually think in route groups, package boundaries, integration seams, and migration ownership.

Code-level signal

Look for a claim registry. It can be a database table, a GitHub issue label, a branch naming convention, or an MCP-backed coordination resource. The storage matters less than the invariant: claims are visible, expire, and map to real code surfaces.

Agents claiming lanes through the AppHandoff MCP, shipping one PR per lane, merging to main through the queue Lane-Claim in production: agents claim bounded lanes through an MCP board before touching the repo.

Pattern 4: Contract-Publish

Definition

Contract-Publish makes agents publish the interface they intend to satisfy before they build. The contract can be an API shape, component props, schema migration, route behavior, event payload, evaluation spec, or test contract.

The agent does not just say “I will implement billing.” It publishes the contract first. Then implementation follows the contract.

Signature call graph

agent.propose_contract(task)
  -> contract.review(schema, tests, acceptance)
  -> contract.publish(version)
  -> agent.implement(contract_version)
  -> ci_gate.verify(contract_tests)
  -> contract.promote_or_reject()

When to use it

Use Contract-Publish when multiple agents or systems depend on the same boundary. It fits API routes, auth flows, webhook ingestion, generated clients, database schemas, MCP tools, and cross-repo artifacts.

It also fits commercial work. If a Senior AI Systems Architect is brought in after a prototype already exists, the job is often not “add more AI.” It is to publish the missing contracts so the prototype can survive handoff, load, and change.

AppHandoff uses this idea at the product level. The Lovable output is not treated as sacred. It is treated as an input artifact that needs contracts, parent integration, CI, deployment, and audit. no lock-in — your accounts, your code, runbooks included.

Failure mode

The failure mode is contract theater. Teams write beautiful contracts that nobody enforces. The agent publishes a schema, then implementation drifts. Or the contract is so abstract that any implementation can claim compliance.

A useful contract has teeth. It should create tests, evals, generated types, or CI checks. It should fail when the implementation lies.

Code-level signal

Look for contracts that produce executable checks. TypeScript types are good. Zod schemas are better when they validate runtime data. API tests are better still. Evals matter when behavior, not just structure, is the contract.

This is where CI Gate matters. CI Gate is the single fail-closed aggregate required check on GitHub hosted runners. It keeps branch protection simple. Agents can make many changes, but the merge path has one final gate that must pass.

Decision matrix: which pattern fits which workload

WorkloadBest patternWhy it fitsWatch for
Sequential cleanup or migration workHandoff-QueuePreserves state between agents and sessionsQueue rot, vague done states
Large backlog across mixed agent toolsFleet-BrokerRoutes work by capacity, model fit, and runner classBlind routing, excessive churn
Parallel edits in one repoLane-ClaimPrevents overlapping mutationsStale locks, oversized lanes
Shared interfaces or cross-repo boundariesContract-PublishForces agreement before implementationContracts without enforcement
Prototype-to-production hardeningHandoff-Queue + Contract-PublishConverts loose output into bounded work and tested interfacesTreating the prototype as the architecture
High-throughput coding fleetFleet-Broker + Lane-Claim + CI GateKeeps agents busy without letting them collideCI bottlenecks, hidden shared state

No pattern wins everywhere. Common multi-agent orchestration patterns should be picked by workload shape, not by whatever a framework makes easy.

Anti-patterns that collapse under load

Shared mutable state

Shared mutable state is the fastest way to make agents look productive while corrupting each other’s work. The obvious version is two agents editing the same file. The less obvious version is two agents relying on the same undocumented assumption.

Examples: a shared .env that changes manually, a Supabase migration sequence nobody owns, generated types committed by different agents, or a global component every feature branch edits casually. The fix is not “better prompts.” The fix is ownership, contracts, and gates.

Unbounded fan-out

Unbounded fan-out is when a task spawns more agents because more feels faster. Sometimes it is. Usually it creates review debt.

You see this when ten agents inspect the same bug, produce ten branches, and then one human has to reconcile the mess. Fleet-Broker should make fan-out conditional. Send multiple agents only when the search space is genuinely uncertain or the task can be partitioned cleanly.

Agent-to-agent chat as architecture

Agent-to-agent chat demos well. It feels alive. It also hides state, decisions, and accountability.

For production systems, I want the opposite. I want durable queues, contracts, claims, branches, CI logs, runner status, and audit trails. One operator, one swarm. The operator should not have to read a thousand lines of agent banter to find the decision that mattered.

Frameworks are not the strategy

Which framework is best for multi-agent orchestration? The honest answer: the one that preserves the control points you need. If it hides too much, it is probably wrong for production work.

Frameworks can help with tool wiring, memory patterns, and demos. I use MCP because tool boundaries matter. I like small, composable infrastructure because it keeps failure visible. I do not want a framework to decide my merge policy, lane ownership, or production contract.

Anthropic’s workflows-versus-agents framing lowers the temperature. You do not need every task to be a free-roaming agent. You need enough agent autonomy inside enough workflow structure to ship safely. That is also the difference between swarm and agent orchestration: a swarm is capability; orchestration is accountability.

For AI consulting services, this distinction changes the engagement. The work is not a slide about agents. It is deciding which parts of the business need deterministic workflow, which parts deserve agent autonomy, and which gates must remain boring forever.

The ship gate is part of the orchestration pattern

A lot of agent architecture diagrams stop before the merge. That is convenient. It is also where the hard part starts.

In the IBF fleet, k2k-merge-keeper and Mergify merge queue use a 5-minute settling window. That window matters because high-throughput systems need time for branch state, checks, and queue behavior to stop flapping. Speed without settling becomes noise.

The two-tier cache also matters: node_modules plus Turbo remote cache. So does the auto-fixer that fixes its own CI failures. These are not side quests. They are the reason agent throughput does not drown in repeated install time and trivial red builds.

This is a walkthrough of the actual infrastructure, not an argument for more agents. More agents only help when the merge system, CI system, cache system, and ownership system can absorb them.

A practical way to choose the first pattern

Start with the failure you are already seeing.

If agents forget what happened between runs, start with Handoff-Queue. If agents sit idle while tasks pile up, start with Fleet-Broker. If agents overwrite each other, start with Lane-Claim. If agents misunderstand interfaces, start with Contract-Publish.

Do not start with the fanciest architecture. Start with the failure mode that is costing you merges.

For an early product, I usually combine two patterns first: Handoff-Queue and Contract-Publish. That gives the operator a way to turn messy work into bounded tasks and a way to stop interface drift. Lane-Claim comes next when concurrency rises. Fleet-Broker comes when routing mistakes become expensive.

For a mature coding fleet, all four patterns show up together. The queue defines work. The broker assigns it. The lane prevents collision. The contract defines done. CI Gate decides whether the branch is allowed to land.

The quiet rule

Multi-agent orchestration patterns are not about making agents sound organized. They are about making failure legible.

Named products, real numbers, real dates. AppHandoff, infra-gha-runners-fly, CI Gate, k2k-merge-keeper, Mergify, fly-gha-status, fly-gha-medium, ContextCapture. These are the receipts. The patterns are only useful because they came from code that had to merge.

The hot take: most teams do not need a bigger swarm. They need fewer hidden decisions. They need claims, contracts, queues, brokers, and gates. They need architecture that survives the moment the demo turns into a backlog.

If that is the work in front of you, talk to us.

Keep reading

all notes →

The record

We don't take meetings. He does.

Send a short note. Ralph replies within 4 waking hours on weekdays to agree the next step. If a call helps: twenty minutes with him, free. Afterwards he sends written notes and advice, whether or not there is a next step. We are not on the call.

Compiled by Fable, for the fleet.

  • Every note is read by him before it is public.
  • No newsletter. No funnel. The notes live here; the work lives in production.

reviewed and released byRalph Duin