DEV Community: Switchman

Running Multiple AI Coding Agents in One Repo Broke Fast. So I Built Switchman.

Switchman — Fri, 20 Mar 2026 11:33:17 +0000

Most AI coding tools help one agent write code.

The hard part starts when you run multiple agents in the same repo.

That is when things get messy:

two agents edit the same file
three agents solve the same problem in different ways
nobody knows what should land first
you become the human traffic controller

So I built Switchman.

Switchman is an open-source CLI that coordinates multiple AI coding agents working in one codebase.

You start with one command:



switchman start "Add user authentication"

I Tried Running Multiple AI Coding Agents on One Repo. It Got Messy Fast.

Switchman — Fri, 13 Mar 2026 21:48:08 +0000

Everyone talks about AI coding agents like the hard part is getting them to write code.

It isn’t.

The hard part is what happens after you have 3, 5, or 10 agents all trying to push work forward in the same codebase.

That’s where things get weird.

Not in a “the models are bad” way.

In a much more boring, painful way:

two agents touch the same file
one finishes work that quietly makes another stale
three branches all look fine on their own and then collide at merge time
nobody knows what should land next
humans end up doing project management for the agents instead of actually shipping

I built Switchman because I kept feeling like the tooling around AI coding was missing the actual problem.

We have tools for:

generating code
editing code
opening PRs
running in isolated environments

But once multiple agents are involved, the real problem becomes:

How do you coordinate parallel software work without turning your repo into chaos?

The moment it clicked for me

At first I thought the problem was simple.

“Just give each agent its own branch.”
Or:
“Just use Git worktrees.”
Or:
“Just let merge conflicts happen in PRs.”

And to be fair, those things help.

But they don’t solve the actual coordination layer.

Worktrees give agents isolated checkouts.

Branches give them isolated histories.

Neither one answers:

who should work on what
how to stop duplicate work early
how to catch overlap before the end
how to know what became stale
how to decide what should land next
how to merge parallel work safely without babysitting it

That’s the gap I kept running into.

The problem wasn’t “how do I isolate agents?”

It was:

How do I run several agents at once and still trust what’s happening?

What actually breaks when you try this

Once you move past one-agent demos, the failure modes are pretty predictable.

1. Duplicate work

Two agents end up solving the same problem from different angles because nobody assigned clear ownership.

2. Silent overlap

They don’t even have to touch the exact same file. One changes a shared module, another builds on assumptions that are now outdated, and the collision only shows up later.

3. Stale work

One agent finishes something important, and another agent’s “done” work is now not really done anymore.

4. Merge queue pain

Even if every branch looks valid on its own, you still need to decide:

what lands first
what waits
what should be retried
what needs review
what is too risky to merge yet

5. Humans become the scheduler

This is the part nobody advertises.

Without a coordination layer, the human ends up doing all of this manually:

routing work
checking overlap
resolving priority
deciding merge order
figuring out what broke what
telling agents what to retry

At that point, “parallel agents” can actually create more overhead instead of less.

What I think the real workflow is

The workflow is not:

one prompt -> one agent -> one result

That’s too small.

The real workflow for AI-native software teams is closer to this:

Several goals arrive at once.
The work gets broken into parallel tasks.
Agents and humans move at the same time.
Overlap, drift, and stale work need to be caught early.
Validation and review need to happen in the right places.
Someone has to decide what is safe to land, and in what order.
The repo needs a trusted path back to main.

That’s the workflow I think tools should own.

Not just code generation.

Parallel software change.

What I built instead

Switchman acts more like a control layer than a code-writing tool.

The idea is simple:

hand out tasks
claim files before editing
block overlap early
detect stale work
keep work visible
run checks before landing
queue finished branches
land the right work safely

So instead of “let a bunch of agents loose and hope Git sorts it out,” the flow becomes more like:

here’s who owns what
here’s what’s blocked
here’s what got stale
here’s what should land next
here’s the exact command to recover when something goes wrong

That sounds small on paper.

It feels very different in practice.

The part I didn’t expect

The interesting thing is that once you solve the coordination problem, the product stops feeling like “file locking for AI.”

It starts feeling more like operational trust for AI-driven software work.

Because teams don’t really just want faster code generation.

They want to be able to say:

we can run many agents at once
we know what they’re doing
we know what changed
we know what got invalidated
we know what is safe to merge
we know why something was blocked
we can recover when workflows get messy

That’s a much bigger category.

And honestly, I think that’s where the real value is.

The pushback I hear most

A common response is:

“Why not just use worktrees?”

I think that’s a fair question.

Worktrees are part of the setup.

They’re useful.

They help with isolation.

But they don’t solve the coordination problem on their own.

They don’t decide who should work on what.

They don’t stop duplicate effort.

They don’t detect stale work.

They don’t manage the landing queue.

They don’t explain what should happen next.

They solve isolation.

They do not solve orchestration.

And once you have several agents moving at once, orchestration is the real problem.

What changed recently

The project has evolved a lot from the early version.

It now has much better support for:

safe landing flows
synthetic landing branches for multi-branch work
stale-work recovery
queue planning
operator-friendly status
PR / CI summaries
policy-aware landing
repair and self-healing flows
clearer “why blocked?” explanations

One thing I cared about a lot was the first-run experience.

If a tool like this is going to matter, it can’t just be powerful.

It has to feel understandable in the first few minutes.

So a lot of recent work went into making:

switchman setup
switchman demo
switchman status

feel much more obvious and less intimidating.

What I think happens next

I think the next wave of developer tools is going to split into two camps.

Camp 1: “better coding”

Tools that help a single developer or agent write code faster.

Camp 2: “better software change”

Tools that help teams coordinate, govern, and land software work safely when lots of parallel work is happening.

I’m much more interested in the second one.

Because as soon as multiple agents become normal, the bottleneck stops being code output.

The bottleneck becomes:

coordination
merge risk
review routing
stale work
trust

That’s what I’m building for.

If you’re experimenting with multiple agents

My strong opinion is this:

Don’t stop at isolation.

Isolation is necessary, but it’s not enough.

If you want multiple agents to be genuinely useful in real repos, you need a way to coordinate the work and control the path back to merge.

Otherwise you’re just moving the mess to a later stage.

Try it

If you want to play with it:


bash
npm install -g switchman-dev
switchman setup --agents 3
switchman demo

I got tired of AI coding agents stepping on each other, so I built Switchman

Switchman — Thu, 12 Mar 2026 17:47:59 +0000

We’re at a weird point in software development.

AI coding agents are finally useful enough that you actually want more than one of them running at the same time.

One agent updates auth.
Another writes tests.
Another fixes docs.
Another tries a refactor.

In theory, that sounds amazing.

In practice, it gets messy fast.

They duplicate work.
They edit the same files.
They leave stale half-finished branches behind.
And the “easy” part of parallel AI coding turns into manual coordination and merge cleanup.

That was the reason I built Switchman.

What Switchman is

Switchman acts like a project manager for your AI coding assistants.

It:

hands out tasks
stops agents from editing the same file at the same time
tracks active work
recovers stuck sessions
checks work before merge
lands finished branches safely back onto main

The simplest way to describe it is this:

Git gives you branches. Switchman gives you coordination.

The problem I kept hitting

Running one coding agent is easy.

Running several on one repo is where the real problems start.

Git worktrees help with isolation, but not coordination.

They do not tell you:

which task each agent should take next
who already owns a file
whether an abandoned session should be cleaned up
whether a finished branch is still safe to land
how to merge several completed branches back onto main without babysitting the whole process

That missing layer is what I wanted.

Not another coding agent.

A control layer for the agents I already use.

What using it feels like

The workflow I wanted was:

spin up several agent workspaces
give them clearly separate tasks
keep one status view open
stop collisions early
land finished work safely, one branch at a time

That’s what Switchman does now.

A typical first run looks like this:


bash
switchman setup --agents 5
switchman verify-setup

switchman task add "Implement auth helper" --priority 9
switchman task add "Add auth tests" --priority 8
switchman task add "Update auth docs" --priority 7

switchman status --watch
switchman gate ci

How to Run 5 Claude Code Agents in Parallel Without Them Overwriting Each Other

Switchman — Tue, 10 Mar 2026 18:22:38 +0000

I was about an hour into what felt like a genuinely productive session. Three Claude Code instances running, each working on a different part of the codebase. It felt like having a small team.

Then I checked the git diff.

Two of the agents had been editing auth.js at the same time. One of them finished first. The other one saved over it. Two hours of work from agent one — gone. No warning, no conflict marker, nothing. Just silently overwritten.

That's the thing nobody tells you about running parallel agents. Claude Code is incredible. Running multiple instances is even better. But they have absolutely no idea what each other is doing. There's no shared brain, no "hey, I'm working on that file" signal. Each one just does its thing and assumes it has the whole codebase to itself.

So I built Switchman to fix it. This is how to use it.

Before you start

You'll need:

Node.js 22.5+
Git 2.5+
Claude Code

Install Switchman:

npm install -g switchman-dev

The idea in plain English

Switchman does three things that Claude Code doesn't do on its own:

It gives your agents a shared task list. You add the work upfront, and each agent picks up one task at a time. No two agents ever get the same job.

It adds file locking. Before an agent touches a file, it checks in. If another agent already has that file, it gets told immediately and picks something else instead. The collision never happens.

It connects to Claude Code automatically via MCP. You don't write any coordination logic. You just open Claude Code in each workspace and it handles the rest.

Step 1 — Create your agent workspaces

The first thing you need is a separate workspace for each agent — its own copy of the repo, on its own branch. If two agents are working in the same folder, they'll step on each other no matter what.

Run this once from your project:

cd my-project
switchman setup --agents 3

That's it. Switchman creates three isolated workspaces and sets everything up:

✓ Switchman ready — 3 agent workspaces created

  ✓ /Users/you/my-project-agent1
    branch: switchman/agent1

  ✓ /Users/you/my-project-agent2
    branch: switchman/agent2

  ✓ /Users/you/my-project-agent3
    branch: switchman/agent3

Each workspace is on its own branch. Whatever one agent does stays completely separate until you decide to merge it.

Step 2 — Tell Claude Code about Switchman

Open ~/.claude/claude_desktop_config.json and add this:

{
  "mcpServers": {
    "switchman": {
      "command": "switchman-mcp",
      "args": []
    }
  }
}

Restart Claude Code. Your agents can now use Switchman's coordination tools automatically — they don't need to be told how, that comes in the next step.

Step 3 — Add CLAUDE.md to your repo root

This is the file that tells your agents what to do. Without it, they won't know to coordinate.

curl -O https://raw.githubusercontent.com/switchman-dev/switchman/main/CLAUDE.md

It instructs each agent to check in with Switchman at the start of every session, claim files before editing them, and release everything when they're done. You write this once and never think about it again.

Step 4 — Add your tasks

Think about what you want to get done and break it into separate chunks. The more independent each task is, the better parallel agents work.

switchman task add "Implement OAuth login flow" --priority 9
switchman task add "Add rate limiting to API routes" --priority 7
switchman task add "Write tests for auth middleware" --priority 6
switchman task add "Update API documentation" --priority 3

Higher priority tasks get picked up first. Each agent gets one task at a time — when it finishes, it picks up the next one.

Step 5 — Open Claude Code in each workspace

Open a separate Claude Code window in each of the three folders that switchman setup created. Each agent will pick up a task, lock the files it needs, do the work, and release everything when it's done.

You just watch it happen.

Here's what it looks like when two agents try to grab the same file:

# Agent 1 locks auth.js
✓ Claimed src/middleware/auth.js

# Agent 2 tries to claim the same file
⚠ Conflict — auth.js is locked by agent1

# Agent 2 picks different files and carries on
✓ Claimed src/middleware/validate.js
✓ Claimed src/routes/tasks.js

Agent 2 doesn't stop or ask you what to do. It just adapts and keeps going. Both agents make progress and nothing gets overwritten.

Checking in

At any point you can see exactly what's happening:

switchman status

Tasks:
  Pending      2
  In Progress  3
  Done         1

Active Tasks:
  agent1 → "Implement OAuth login flow"
  agent2 → "Add rate limiting to API routes"
  agent3 → "Write tests for auth middleware"

Active File Claims:
  agent1: src/auth/login.js, src/auth/token.js
  agent2: src/middleware/rate-limit.js, src/server.js
  agent3: tests/auth.test.js, tests/middleware.test.js

Three agents, all working, no overlap anywhere.

Before you merge

When everything's done, run this before merging any branches:

switchman scan

It checks for any file overlaps or branch conflicts and tells you exactly what to fix before you touch anything. Much better than finding out at merge time.

Does it actually work?

The first time I ran three agents through a real feature with Switchman, I genuinely just went and made a coffee. Came back twenty minutes later, all three were done, no conflicts, nothing to untangle. That hadn't happened before.

It won't solve everything. If your tasks aren't well scoped, agents will still get stuck. And if you're merging a lot of branches, you'll still need to think about that. But the silent overwrite problem — the one that cost me two hours that afternoon — that's gone.

Switchman is free and open source.

Install: npm install -g switchman-dev

GitHub: github.com/switchman-dev/switchman

Site: switchman.dev