| Item | Work | Lane | Agent | Status |
|---|---|---|---|---|
| GIT-8817 | Rate-limit retry in webhook worker | standard | codex · reviewed by claude | MERGED |
| GIT-8841 | Batch 12 approved PRs · integration | drain | ci-router · full suite | VALIDATING |
| GIT-8823 | Flaky snapshot in billing suite | lite | claude · reviewed by codex | IN REVIEW |
| GIT-8834 | Rotate signing keys · r3 | human | — held for operator | HUMAN GATE |
| GIT-8831 | Migrate audit log to append-only store | deep | claude · reviewed by grok | DISPATCHED |
| GIT-8840 | Add rate-limit headers to public API | lite | claude · reviewed by codex | TRIAGED |
How the line runs
A rail yard doesn't get faster by adding locomotives. It gets faster by never letting two trains claim the same track. Every piece of work in SwitchYard rides the same five stations.
One door into the yard.
Engineers, bug reports, monitoring alerts, other agents — everything enters through the same authenticated gate, and nothing enters half-described. A request without a risk level, a scope, or a clear ask gets sent back with specific questions. What comes out the other side is an issue the rest of the yard can act on without guessing.
AUTHENTICATED INTAKE GATE
The yard sorts itself.
Triage runs every few minutes — or the moment you ask — and puts the whole queue in order. It classifies, dedupes, and routes; it never implements. Every item leaves with a lane matched to its difficulty, a project matched to your roadmap, and dependencies the dispatcher can plan around.
INTENSITY-ROUTED LANES
The grade travels with the item and decides everything downstream — which model builds it, how hard review pushes, and what it takes to merge:
| Lane | Who builds it | Who reviews it | How it merges |
|---|---|---|---|
| Lite r0–r1 | Fast, cheap model | Rival vendor, one tier up | Auto — next batch |
| Standard r2 | Mid-tier model | Rival vendor, one tier up | Auto — next batch |
| Deep complex | Frontier model | Frontier rival | Auto — next batch |
| Human-gated r3–r4 | Any lane | Rival + a named human | Holds for sign-off |
Parallel, never chaotic.
Waves of headless agents launch into isolated worktrees — sized to your model budget, chosen so no two touch the same files, spread across your machines. Every session is watched until it reaches a terminal state, and every pull request faces a rival vendor's model in review before it counts as done. A stuck agent gets escalated or relaunched. It does not get forgotten.
SUPERVISED PARALLEL SIDINGS
The only stage that merges.
Approved PRs don't race each other to main — they leave in scheduled batches. SwitchYard builds one combined tree from the non-overlapping approved set, runs the full suite against fresh main exactly once, and merges the clean set together. Whatever fails is re-queued with the evidence attached. Main stays green at any fleet size, and CI bills you for one validation instead of forty.
BATCHED CONVERGENCE TO MAIN
The yard feeds itself.
Shipping work creates work. Reviewers file findings, batch runs surface regressions, and merged features raise their next questions. SwitchYard catches all of it as structured issues and routes it straight back to intake — so the next wave starts where the last one left off, not from a stale backlog.
THE LOOP FEEDS ITSELF
Station 03, up close
Dispatch isn't "launch agents and hope." Every wave goes through the same four-step planning pass before a single session starts.
Bring your own keys and subscriptions — Anthropic, OpenAI, xAI. SwitchYard reads how much of each weekly limit remains and plans against it, minus the headroom you tell it to keep free.
Every issue is graded for risk and for the intelligence it actually needs. Typo fixes ride the lite lane on cheap models; migrations get a frontier model on deep. No token spends above its pay grade.
Dependencies, blocking relations, and the files each issue will touch form one graph. Dispatch selects the largest set that can't collide — and holds everything else for a later wave.
The wave launches within budget, spread across your machines, supervised to terminal state. When limits tighten mid-week, the next wave shrinks instead of stranding work.
Between stations 03 and 04
Every pull request faces a reviewer from a rival vendor — a model you choose, running a tier above the one that wrote the code. And the reviewer can say no as many times as it takes.
THE REVIEW PAIRING IS CONFIGURATION, NOT CHANCE
The safety rails
Autonomy without limits is just an incident with a delay timer. Three governors run continuously, and no agent can talk them out of it.
Every wave is sized to what's actually left of your weekly limits — per vendor, per window — minus the headroom you reserve. A glidepath rations the week so Monday's enthusiasm can't strand Friday's work on a rate-limit wall.
Dispatch is capped by the merge rate. When the approved backlog backs up, the yard stops accepting new trains until integration clears it — so you never wake up to a thousand-PR graveyard.
Agent worktrees are real disk and real state. A state-driven janitor reaps them the moment their work merges — the yard never hoards dead branches, dead sessions, or dead gigabytes.
Where people stay in charge
Between stations, SwitchYard drives itself. At the two places you said people decide, it stops dead — and no agent can flip those signals from the inside.
Credentials, production controls, anything your policy marks human-only: routed to a human queue at triage and never auto-dispatched. Not "discouraged." Never picked up.
Elevated-risk changes build, test, and pass review like everything else — then hold at approved until a named person signs off on the record. Integration will not cross this signal, ever.
Why teams switch
Most teams already have coding agents. What they don't have is a system that makes a fleet of them behave like an engineering org.
Rollout
SwitchYard runs against the GitHub and tracker you already have. No new infrastructure, no migration project. Connect, set your gates, dispatch.
Point SwitchYard at a repo and your tracker. The preflight doctor tells you exactly what's wired, what's missing, and what's optional — before anything moves.
Provision the lifecycle, mark the human-only labels, set the merge-gate policy. Dry-run the queue and read the dispatch plan while it's still just a plan.
Dispatch opens on the low-risk lanes and the board goes live: real issues triaged, built in isolated worktrees, cross-vendor reviewed — and held at every gate you just set.
Enterprise posture
The enforcement boundary is server-side policy — protected branches, required review, scoped credentials — not a system prompt asking agents to behave.
State transitions, review verdicts, gate approvals, merges — all recorded in your tracker and Git history. "Why did this ship?" has a URL for an answer.
Agent write access is issued per profile, per repo, per path glob — with TTLs and revocation. Anything outside the issued scope fails closed.
Doer and reviewer roles route across Anthropic, OpenAI, and xAI models by policy and live capacity. Swap vendors without touching the pipeline.
Runs against your GitHub, your tracker, your machines. Hosted workers, alerting, and backups are optional add-ons — each independently detachable.
If a session dies mid-flight, disposition policy finishes what's recoverable and cleanly re-queues the rest. No limbo states, no forgotten branches.
SwitchYard operates inside your branch protection and required reviews — it never asks for admin bypass, and it can't grant itself one.
Every agent mutation flows through schema-enforcing middleware. Malformed writes bounce with the reason; valid ones land with provenance attached. Agents never touch your tracker or repo raw.
The same middleware nudges every session to file what it finds — findings, evidence, follow-ups — as structured issues. The system gets richer with each wave, not messier.
The fine print
Get on the timetable
Connect one repository and set your gates. Twenty minutes later the board is live and the first wave of agents is shipping real work — stopping exactly where you said stop.