switchyard

Many agents, one main.

Build software with fleets of autonomous agents. Switchyard coordinates their work across a shared codebase, manages conflicts and continuously integrates changes.

Agents and people, then Switchyard, then main on GitHub Three small figures for agents and a person send their work along a rail into one Switchyard block whose merge queue is filled in violet; a rail runs out of it to a filled block that is main, which follows GitHub. agents and people Switchyard main on GitHub

Works with the agents and tools your team already runs

  • GitHub
  • Claude Code
  • Cursor
  • Codex
  • any MCP agent
  • yard CLI
  • plain Git

Any repository. Many agents. One main.

agents at once on one project, every task merged
100
from submit to merged on a 1 GB repository
seconds
repositories, whole history included
multi-GB

Agents use plain Git, the yard CLI or MCP.

for agents: connect over MCP
claude mcp add --transport http switchyard \
  https://app.switchyard.so/v1/projects/<project>/mcp

Claude Code shown: run /mcp in it to sign in, with no key. Codex signs in the same way; Cursor and other clients connect with a key.

open the agents guide at Connecting

The problem, and the fix.

the problem

Agents collide

Put ten agents on one repository and they get in each other's way. Two rewrite the same function. A third builds on code that is about to change. Nobody finds out until the merge fails.

the fix

A task per agent, merged live

Every agent works in its own task. On every push Switchyard merges main with every task and tells both agents when their work overlaps, with one suggestion each. Steps 01 and 02.

the problem

Pull requests were built for people

One author, one branch, one reviewer with time to read. Agents open dozens of changes an hour, and the review queue becomes the bottleneck. Writing the code is fast; merging it is slow.

the fix

Tested together, landed in one push

Submitted tasks are tested together on top of main and land in one push. A broken task is found and sent back while the rest merge. A person reviews only what the rules say needs one. Steps 03 and 04.

Everything between a push and main.

Features.

  • A task per agent. Its own copy of the repository and a key that pushes there and nowhere else, through Git, the yard CLI or MCP.
  • Plans and warnings. Agents say what they will touch; overlaps are flagged before code is written.
  • Merged live on every push. Main merged with every task, same-file and same-symbol warnings with one suggestion each.
  • Conflicts that never block. A conflict is a commit; five steps fix it in order: Git merge, file rules, code rules, an AI suggestion, a person.
  • A merge queue in batches. Up to 32 tasks tested together on main; the broken one is found by halving and sent back, the rest land in one push.
  • Checks in containers. Small or large machines, a pass on the same code reused, logs kept 30 days, a failed check's machine kept for a shell.
  • Rules in one file. Which checks run, what needs a person, owned paths, what needs no check.
  • A review inbox. Changes waiting for a person with the reasons and the paths; approvals made on GitHub count.
  • GitHub stays in step. Merges land on GitHub first, pushes made there flow back, a protected main lands through a pull request, and work carries on while GitHub is down.
  • Tests on GitHub Actions. Wait for your own checks, or run their jobs on Switchyard's machines with runs-on: switchyard.
  • Signed merge records. Who approved, which checks passed, checked with yard verify.
  • Headless. Everything the board does is an API route, a yard command and an MCP tool; webhooks for the rest; every doc page as markdown for agents.
  • Billing by the second. Four meters, a spending limit that holds work rather than losing it, statements reviewed before a charge.
  • Undo. Every action recorded and undoable.

How it works.

Four steps, each one a thing you can watch on the board.

  1. step 01

    A task per agent

    Each agent gets its own copy of the repository and a key that can push there and nowhere else, through plain Git, the yard CLI or MCP.

  2. step 02

    Merged live, warned early

    On every push Switchyard merges main with every task and tells both agents when their work overlaps, with one suggestion each.

  3. step 03

    The merge queue lands it

    Submitted tasks are tested together on top of main in a fresh container. What passes lands in one push; a broken task is found and sent back, the rest merge.

  4. step 04

    GitHub stays in step

    Merges land on your GitHub repository first and pushes made there flow back. When GitHub is down, work carries on here and lands when it returns.

Pricing.

launch$20a month minimumrepositories up to 3 GB each
scale$200a month minimumrepositories up to 8 GB each

Every plan has the whole product; your usage counts against the minimum on four meters: check minutes, engine time, AI suggestions and repository storage. Prices are in US dollars.

see pricing

Once you are in: two steps

Switchyard is in private beta. Join the waitlist and we write when there is room for you; then these two steps start your first task.

1Install yard and sign in

curl -fsSL https://app.switchyard.so/install.sh | sh
yard login https://app.switchyard.so --github

macOS and Linux. One binary on your path; the sign-in opens a page where you approve a code. Then follow the quickstart.

2Start a task and run your agent in it

yard --project acme-web branch new 'Add sales tax to cart totals' --dir sales-tax
cd sales-tax
yard agent setup --yes
yard agent run -- claude

Starts a task in its own directory, writes the Switchyard skill and the MCP entry in .mcp.json there, and hands the agent the task's key. Use codex or cursor . in place of claude; the set-up page prints the MCP lines for those two.

Questions.

Who holds my code, and will you train on it?

GitHub stays the authority. Switchyard keeps a copy of the repository, as any CI does, because tests and merges run on it. Delete the project and the copy is removed 30 days after the deletion. Conflict records are shared only when an admin turns sharing on in the project's settings. It is off by default.

Nobody reviews every line any more. What is the merge queue protecting?

Main. Checks gate every merge. Your rules send any path you name to a person, and a protected path waits for someone other than the person who started the task. A batch that fails is halved to the task to blame, and the rest merges. Switchyard does not judge code quality and does not claim AI review.

What is different from GitHub?

GitHub reviews code as if a person wrote it: one author, one branch, one reviewer. Switchyard is the layer for many agents writing against one main. Each agent has a task. Warnings come before they collide. A queue tests batches and finds the one to blame. Conflicts are fixed by rules, or by a suggestion a person approves. The result lands on GitHub. Nothing here asks a team to leave GitHub.

What happens when Switchyard is down?

Agents and people work in plain Git clones, and Switchyard is a remote. A push waits, and the work stays on the agent's disk. Main stays on GitHub, and people keep working there. The outages page says what happens when GitHub is the one that is down.

Why not just Git?

Git is fine. The limit is many agents pushing to one branch, the review queue, the checks bill, and the merge that lands broken at 3 a.m. Switchyard uses unchanged Git under everything and adds the queue, the checks and the conflict steps.

Join the waitlist.

We are opening the hosted version to teams a few at a time. Leave your email and we will write when there is room for you.

We keep your email, your two answers, your browser's user agent and when you joined, to plan the rollout. We do not store your IP address. The founder sees who joined. We send one email to say you are on the list, and one when there is room.