Multi-Agent Orchestration

How many agents work as one organization without writing over each other.

Agents propose file changes. The workflow removes what a run may not keep. Here are the counts, and what they cannot see.

By Justin Bartak. Updated .

The workflow keeps changes the run is allowed to save and removes the others before saving a commit, the repository's record of a change. It removed 147 file paths: 124 proposed lessons that the closed lessons gate discarded, and 23 other paths outside the run's allowed set. A seat's lessons can land only from stage 3 of the release ladder, and then only as proposals. The record counts 241 stats rows from to , including skips and infrastructure failures. The field note counts 226 runs that actually ran and excludes 15 skipped, halted or infrastructure rows. Those totals describe different populations.

Of the removed files, the 23 paths outside anything a run may keep came from nine runs. The record does not identify those files or who wrote each one.

This page explains how the agents share work without writing over each other.

What is multi-agent orchestration?

It is how many AI agents do one organization's work without stepping on each other. One agent needs a good prompt and a check at the end. Many agents need three more things: a lane for each, a rule for who lands first, and a way to hand work from one session to the next.

At Orbyt Labs the agents run the company's operations: twelve self-named agents, eleven officers and the Inspector General, across eleven registry departments, two of them wound up. They run on GitHub Actions, most of them through one shared workflow action, and the Chief of Staff turns their reports into one briefing for the founder.

The rule that holds it together is the third article of the organization's constitution: the workflow commits, never the agent. An agent produces work. The workflow decides whether that work lands.

None of the parts is new. Parallel agents, sandboxes, CI gates and code review are common practice. This page adds a dated record of one organization running them, including the counts that came out wrong. The sample is one organization, graded by its own checks.

How do you keep many agents out of each other's work?

With a lane per seat, enforced twice. A lane is the set of paths a seat is told to write, declared in its spec. A writer fence confines hosted Bash while the agent runs, and its check requires an observed Bash denial. Write and Edit are cleaned up afterward; the fence does not refuse those writes at runtime. Then, before the commit, every path the run changed outside what it may keep is reset and counted.

That count is the part worth reading. Across 241 seat runs the workflow reset 147 paths. In 124 runs the closed lessons gate discarded a proposed lesson, one path each, and those paths account for 124 of the 147. The lesson file is inside the seat's lane; the gate opens it for landing only at a later stage of the release ladder. The other 23 paths, in nine runs, fell outside anything the run may keep, and four of those runs were Autonomous Content runs and two were Marketing Reports runs.

Most of what the workflow reset was a lesson the seat was told to propose and the gate was not yet letting land, as far as the counts and the code can show.

Seat runs by week, and how each ended

241 seat runs over 18 weeks, by how each ended: 209 landed, 11 skipped and 21 refused or failed. Under each week, ticks count the paths the workflow reset: 124 proposed lessons the closed lessons gate discarded and 23 outside the lane.

  • Landed
  • Skipped
  • Refused or failed
  • Upper row: proposed lessons the closed lessons gate discarded
  • Lower row: paths outside the lane
  • Week only partly inside the rows on record (hollow)
Each column is one week of seat runs, July to November 2026, stacked by how the runs ended, with its height on one scale: the tallest week holds 25 runs. Under each column, an upper tick counts the proposed lessons the closed lessons gate discarded and a lower tick with a square cap counts the paths outside the lane, both on one scale whose largest is 11 paths. Drag, tap or use the arrow keys to read a week.
  • Weeks run Monday to Sunday in UTC.
  • A run whose own stats row did not land on main (a red main, a lost push) is absent, so each week and each band is a floor.
  • 2 weeks are only partly inside the rows on record, so they hold fewer than seven days of runs (hollow columns).
  • Refused or failed adds three outcomes the table keeps apart: refused, failed and infrastructure fault.
  • The org's committed stats corrections re-bill 3 rows whose outcome the harness, not the seat, decided: 3 refused as recorded, drawn here as 3 infrastructure faults.
  • The ticks under the columns count paths the workflow reset, one for each file path, and are not runs.
  • 12 of the 241 rows come from a workflow no seat spec names (Advisory Panel (observers)). They are counted as runs here.
  • Runs that wrote outside the lane, by workflow: Autonomous Content 4, Marketing Reports 2, Quality Weekly 2, Legal Weekly 1. A stats file is not a seat: one file can hold several workflows.

Not shown. Which paths were reset and what wrote each one: a run records how many paths it reset, not which.

Source: orchestration-figures.generated.json, built by scripts/research/method-figures/multi-agent-orchestration.ts from docs/org/stats/*.jsonl, read through the committed corrections in docs/org/stats-corrections.jsonl.

Rows counted through

The numbers as a table
Seat runs by week, and how each ended
Week ofCoverageRunsLandedSkippedRefused or failedHeld lesson pathsOutside lane paths
Partly inside the record8701 (1 failed)71
Full week121101 (1 failed)60
Full week6204 (4 failed)30
Full week201802 (2 failed)92
Full week770030
Full week10802 (2 failed)511
Full week12903 (2 refused, 1 infrastructure fault)10
Full week11812 (1 refused, 1 infrastructure fault)43
Full week11902 (1 failed, 1 infrastructure fault)60
Full week191711 (1 refused)115
Full week252230101
Full week171403 (2 refused, 1 infrastructure fault)110
Full week12102060
Full week181620110
Full week14131070
Full week15141080
Full week151500100
Partly inside the record990060

Download the data: multi-agent-orchestration-weekly-outcomes.csv, multi-agent-orchestration-weekly-outcomes.json

The run records how many paths it reset, not which ones. Reading the held lesson as one of them comes from the action's code and the counts, never from a path observed one by one. The record also does not say whether an agent wrote each outside path or a tool left it behind, and an out-of-lane rename is counted by its destination only, so its source goes uncounted.

Does the workflow trust an agent that says it finished?

No. Since the line an agent prints at the end of a run is recorded as its claim, beside what the workflow measured, and the workflow decides. Of the 129 runs whose row records that claim, 125 landed. The other four did not. Two of the four were refused for the state of main, not for the run's work.

An earlier refusal, from before claims were recorded, is a public specimen. The content seat closed a run saying all guards were green and all 5,858 tests were passing, and the guard refused the tree. That pair, the claim and the measurement, is what the record now keeps, and the story is on harness engineering.

What each agent claimed, and what the workflow measured

Of 129 runs whose agent said it finished, 125 landed and 4 did not. The other 112 runs carry a different claim or none.

  • Landed
  • Skipped
  • Refused or failed
  • A claim the agent made, or none

Said it finished129 runs

Said there was nothing to do10 runs

No claim recorded102 runs98 before Sep 22, 4 on or after

Landed209 runs

Skipped11 runs

Refused or failed21 runs

On the left, what each run's agent said at the end. On the right, what the workflow measured for the same run. Each band is as thick as its runs, on one scale across all 241 runs on record. Select a bar, with a pointer or the arrow keys, to light the bands that touch it.
  • A run whose own stats row did not land on main (a red main, a lost push) is absent, so each week and each band is a floor.
  • Landed means the stats row's outcome is completion: the workflow's measurement that the run's work was kept, not a check that the work was right.
  • The earliest row with a claim is from Sep 22. The 98 runs with no claim are from before it, and 4 runs on or after it also carry none. All of them are drawn as "No claim recorded".
  • Refused is the outcome word rejected in the stats rows. Refused, failed and infrastructure fault are drawn together as refused or failed, and the table keeps them apart.
  • The org's committed stats corrections re-bill 3 rows whose outcome the harness, not the seat, decided: 3 refused as recorded, drawn here as 3 infrastructure faults.
  • A band of fewer than 3 runs is drawn at least 3 pixels thick so it stays visible; its count is printed all the same.

Not shown. Which run each band was, and whether the claim and the measurement were made close together in time: the record keeps one row per run, with a date and no start or end.

Source: orchestration-figures.generated.json (claims.crosstab), built by scripts/research/method-figures/multi-agent-orchestration.ts from docs/org/stats/*.jsonl, read through the committed corrections in docs/org/stats-corrections.jsonl.

Rows counted through

The numbers as a table
What each agent claimed, and what the workflow measured
What the agent claimedWhat the workflow measuredRuns
Said it finishedLanded125
Said it finishedRefused3
Said it finishedInfrastructure fault1
Said there was nothing to doSkipped10
No claim recorded, before the first claimLanded80
No claim recorded, before the first claimSkipped1
No claim recorded, before the first claimRefused3
No claim recorded, before the first claimFailed11
No claim recorded, before the first claimInfrastructure fault3
No claim recorded, on or after the first claimLanded4

Download the data: multi-agent-orchestration-claim-flow.csv, multi-agent-orchestration-claim-flow.json

What happens when two agents land at once?

The rebase regenerates the shared files instead of merging them. Until every writer shared one concurrency group, so two never collided on a push. Read from the workflow generator that day, it also meant several seats dispatched together would run one, queue one and cancel the rest. Decision D-0059 gave each writer its own group. There are 25 such groups today, across seat and non-seat workflows, which is a count of groups and not of writers.

The rebase regenerates every registered generated file and refuses loudly on one it does not know. On that rule was walked for real: the Chief of Staff pushed seven seconds after the changelog bot, the rebase conflicted on two public ledgers, the resolver died on a module the seat's environment never installs, and a complete, guarded briefing was thrown away. The fix walks every generator's imports and refuses a package the seats do not have.

Writer lanes, one concurrency group each

The workflow files declare 25 writer lanes, each one concurrency group, and GitHub runs at most one workflow run in a group at a time. No two workflows share a lane. 11 of the lanes belong to a seat spec and 14 do not.

  • A lane that belongs to a seat spec
  • A writer with no seat spec
  1. autonomous-contentseat autonomous-content, 19 stats rows
  2. cfo-weeklyseat finance, 1 stats row
  3. chief-of-staff-weeklyseat chief-of-staff, 55 stats rows
  4. engineering-weeklyseat engineering, 14 stats rows
  5. innovation-monthlyseat innovation, 21 stats rows
  6. legal-weeklyseat legal, 29 stats rows
  7. marketing-reportsseat marketing, 2 stats rows
  8. org-changelog-weeklyseat changelog, 25 stats rows
  9. product-weeklyseat product, 31 stats rows
  10. quality-weeklyseat quality, 29 stats rows
  11. security-weeklyseat security, 3 stats rows
  12. advisory-panelno seat spec, 12 stats rows
  13. agent-reposno seat spec, no stats rows on record
  14. ai-exposure-refreshno seat spec, no stats rows on record
  15. blog-figures-refreshno seat spec, no stats rows on record
  16. briefing-ackno seat spec, no stats rows on record
  17. finance-ledgerno seat spec, no stats rows on record
  18. inspector-general-weeklyno seat spec, no stats rows on record
  19. model-refreshno seat spec, no stats rows on record
  20. org-daily-pulseno seat spec, no stats rows on record
  21. org-repairno seat spec, no stats rows on record
  22. org-supervisorno seat spec, no stats rows on record
  23. outside-checkno seat spec, no stats rows on record
  24. repair-creditno seat spec, no stats rows on record
  25. shard-timings-refreshno seat spec, no stats rows on record

main

Each row is one concurrency group a workflow file declares, drawn as a rail that merges into one line for main. A filled dot is a lane that belongs to a seat spec and a ring is a writer no seat spec names. Under each name: the seat spec, and the stats rows its workflow filed.
  • A lane is a concurrency group a workflow file declares. GitHub runs at most one workflow run in a group at a time.
  • Stats rows are joined to a lane by the workflow's own name. 13 lanes have none on record: those workflows do not file stats rows, or have not run. That is not a count of zero runs.
  • The lanes are the org-writers concurrency groups only. The workflow files declare 16 other concurrency groups, which this figure does not draw and does not sort into writers and not: blog-figures-weekly, blog-prepublish-daily, blog-publish, coverage-nightly, fence-canary, indexnow-changed, local-runner-watch, org-configure, org-halt, org-ladder, org-record, provenance-daily, provenance-seal-watch, push-collision-canary, research-distribution and tool-deny-canary.

Not shown. Which lanes ran at the same time: the record keeps one row per run, with a date and no start or end, so overlap is not observed. Also not drawn: 16 other concurrency groups the workflow files declare, named in the caveats.

Source: orchestration-figures.generated.json (writers.groups), built by scripts/research/method-figures/multi-agent-orchestration.ts from .github/workflows/*.yml, docs/org/seats/*.json and docs/org/stats/*.jsonl.

Stats rows counted through

The numbers as a table
Writer lanes, one concurrency group each
LaneWorkflowSeat specStats rows
autonomous-contentAutonomous Contentautonomous-content19
cfo-weeklyCFO Weeklyfinance1
chief-of-staff-weeklyChief of Staff Weeklychief-of-staff55
engineering-weeklyEngineering Weeklyengineering14
innovation-monthlyInnovation Monthlyinnovation21
legal-weeklyLegal Weeklylegal29
marketing-reportsMarketing Reportsmarketing2
org-changelog-weeklyOrg Changelog Weeklychangelog25
product-weeklyProduct Weeklyproduct31
quality-weeklyQuality Weeklyquality29
security-weeklySecurity Weeklysecurity3
advisory-panelAdvisory Panel (observers)None12
agent-reposAgent repositoriesNoneNone on record
ai-exposure-refreshAI exposure refreshNoneNone on record
blog-figures-refreshWeekly blog figures refreshNoneNone on record
briefing-ackBriefing acknowledgedNoneNone on record
finance-ledgerFinance LedgerNoneNone on record
inspector-general-weeklyInspector General Weekly (Agent Gauge)NoneNone on record
model-refreshRefresh AI Model RegistryNoneNone on record
org-daily-pulseOrg Daily PulseNoneNone on record
org-repairOrg RepairNoneNone on record
org-supervisorOrg supervisor (autonomous mode, observe)NoneNone on record
outside-checkOutside-family check (OpenAI cross-model second opinion)NoneNone on record
repair-creditRepair creditNoneNone on record
shard-timings-refreshWeekly shard timings refreshNoneNone on record

Download the data: multi-agent-orchestration-writer-lanes.csv, multi-agent-orchestration-writer-lanes.json

How often a parallel landing is lost is NOT OBSERVED. When a stats row's own push fails, the row goes to the run's artifact instead of main, so the record on main undercounts exactly the runs this section is about.

How does work pass from one agent session to the next?

Through a committed file. A session cannot clear its own context, so the handoff loop makes the clear a process boundary: each iteration is a fresh agent session that reads the newest committed handoff, works its ranked list, never touches the items reserved for the founder, and ends by writing the next handoff. The founder asked for it on in one line: "I want you to be able to do this without me".

Each session has a turn cap, 48 by default. The loop's gate is a new handoff commit and a clean tree, never the last line the agent prints. The loop's agent pushes nothing: it works in its own clone inside the writer fence, and the loop lands its commits through the landing gate, at most eight landings a day by default as a ceiling against a runaway. How long the loop has run, and how each stretch ended, is on autonomous operation.

A clean handoff proves a handoff landed, not that the work in it was right.

How do Codex and Claude split the work, and what record does it leave?

Codex writes under a written contract and Claude grades it. No structured record ties a verdict to the model that wrote the work. So the method below is real, and its pass rate across most weeks is NOT OBSERVED.

The reasoning is that a model grading its own work may share its blind spots. This repository has not measured whether a second vendor catches more than a fresh-context review by the same model. Codex and Claude both run on flat subscriptions, the Codex CLI on a ChatGPT plan and Claude Code on a Max plan, so neither leg is metered per token. Only one shape counts:

  • A written contract names where the data lives, the fallbacks, the tests including the case that must stay quiet, the acceptance commands, and the rules with their reasons.
  • The writer runs detached, in its own copy of the repository.
  • The acceptance commands run on the grader's side, never read from the writer's report.
  • One cold review, in a fresh context, proves each negative case by restoring the old code and watching the test fail, against a fixed base commit, because main moves while the reviewer reads.
  • One rewrite round back to the writer. Then the commit.

The founder's words when the lane widened on , as the repository records them: "use Codex Astra to save Claude tokens and increase the sprint by 2x". From October 8 to anything in the lane went to Codex before Claude; since then new builds go to Claude first. Still out of it: the seat generator, and any item with a founder decision inside it.

On both defects the cold checks found were in the contracts, not in the code. The repository records two ways a contract fails: Codex will not guess where data lives, and it reads a rule literally. A contract that said "no git commands" cost a git diff the work needed, and the fix was "no git commands that change state".

What has cross-model review measured?

Three measurements from two days, each from the session that measured it:

  • , day one: 6 code contracts in 9 runs, three with a second round, plus one read only inventory, in the console repository. Every gate passed on the first try. Each unit took 2 to 9 minutes and cost the main session about 6 turns.
  • , a parallel wave: seven items at once, each in its own copy of the repository, about 3 main session turns per item. Seven of seven passed their gates the first time and seven of seven passed review or passed with nits, with no rewrite round.
  • : seven contracts in parallel, every gate green on the grader's side the first time. One cold review refused the commit on a true finding, pages that narrated receipts nobody could open, and the wave took three rewrite rounds, each smaller than the last.

The comparison everyone wants, the same work done inside the main session, is an estimate of 30 to 40 turns. Nobody ran the control.

Counted on : 843 contract files were written between September 4 and , in a folder on the founder's machine that is never committed, so no reader can recount them. The one committed review series holds 26 cold reviews of five designs; every reviewer was a Claude sub-agent, and the record does not say who wrote the designs.

The record holds both kinds of failure. On the first measured day, , two review findings were about how the written code behaved, and on September 15 a cold review refused a commit on a true finding in the work. The rest on record are seams between tools: a detached run that waited forever on an open input stream, a relative output path resolved against the wrong directory, and a three way patch apply that reports every file clean and then rolls them all back.

The pass rates above are true of the days they describe. Across the other weeks the rate is NOT OBSERVED, commits carry no machine-readable writer field, and Codex's own context cost is not measured. This is a workflow, not a model comparison, and it makes no claim about which model is better.

What does one orchestrated run cost?

Mostly reading. Across the 218 seat runs whose token use is on record, the agents read 173 tokens back from cache for every token they wrote. The seats are scheduled jobs with long instructions, so each turn pays for the whole conversation so far.

This is a different population from the interactive sessions and from the cost-weighted series on the cache-read tax, so never read them as one series. Whether a run's count includes the cache reads of sub-agents it spawned is not checked.

Where does multi-agent orchestration fail?

At the seams. Most of the failures this page cites are not one agent being wrong. They are two correct parts meeting: a seat's checkout that runs no hook, a resolver whose environment lacks a module, a gate that read a line the agent had to place. Each one found becomes a check.

What this record cannot see, stated before any reader asks:

  • Lost parallel landings: NOT OBSERVED. A failed stats push sends the row to the run's artifact, so main undercounts it.
  • Which path each reset was: NOT OBSERVED. The run records how many, not which.
  • An out-of-lane rename's source path: not counted.
  • Cross-model review: no structured record ties a verdict to the model that wrote the work. Its figures are dated notes from two days.
  • Throughput: no measure of how much work the organization finishes per week, or whether more agents finish more.

The per-run record these counts come from is the field note What an Agent Seat Actually Completes.

Multi-agent orchestration questions? Answers.

How many AI agents do one organization's work without writing over each other: a lane for each, a rule for who lands first, and a way to hand work between sessions.

No. The constitution's third article says the workflow commits, never the agent. Paths outside what the run may keep are reset, and a guard gauntlet decides whether the rest lands.

In the record from to , 23 paths in nine of 241 seat runs fell outside anything the run may keep, and the record does not say whether an agent wrote each one. Another 124 reset paths were proposed lessons a closed gate discarded.

Each writer has its own concurrency group, and when two land together the rebase regenerates the shared generated files and refuses loudly on any it does not know.

On the two days measured in September 2026, every acceptance gate passed on the grader's side the first time; reviews found issues in some units, and the September 15 wave took three rewrite rounds. Across the other weeks the rate is not on record, because no structured record ties a verdict to the model that wrote the work.

Cite this page

Cite this page for the practice and follow its sources for the underlying records.

Bartak, J. (2026). Multi-Agent Orchestration. Orbyt Labs Research. https://www.orbytlabs.ai/research/multi-agent-orchestration