How I run many Claude Code agents at once without losing track

For most of this year my day job has looked like this: plenty of repositories (web front-ends, a mobile app, backend services, shared packages), a Jira board or even plans with pen and paper, and somewhere between 10 and 20 Claude Code sessions running at the same time. Some fix bugs, some build the next step of an epic, and one or two do research or write tests.

The agents got good enough that they stopped being the bottleneck. I became the bottleneck - which is quite popular slang in today's world if you even look at all these posts on LinkedIn, Reddit or other socials that include the software dev. This post is about what broke when I scaled from one agent to many, what worked, and the tool I ended up building: Switchboard.

I'd love to take you through my journey of solving the issues I've met in everyday development and how I approach them, ending up with the reasoning behind the solution I'm sharing with you today.

A coding agent's turn ends in one of three ways: it's done, it's blocked, or it's waiting for you. In a terminal those three look identical: a prompt sitting there and waiting for follow-up or just letting me know it is done.

With two agents you notice. With eight, an agent asks "Should I also update the mobile client?" at 10:14, and you find it at 11:30, and then you're like que?, how the hell did I miss that... Multiply that by every session and a large part of the day is agents idling while they wait for a one-word answer. Kinda crazy to think about it in the sense of pure focus and personal management issue (or lack of enough screens to have all the terminals open at the same time:D)

What did work for me was making the agent say which of the three it is. In Switchboard every agent gets a small built-in MCP tool, turn_status. At the end of every turn the agent reports done, waiting for you or blocked, with a one-line ask. If it forgets, Switchboard reads the last message for a trailing question. Everything waiting on me goes into one list: Needs you.

That single list changed my day more than anything else. Instead of cycling through terminals, I clear a queue: questions with their options as buttons, permission prompts, steps that stopped, alerts. One click answers, and there's a five-second undo for when I click too fast.

The second thing I lost was the overview. Which agent is still working, which finished, which is ready for me to review and combine?

Quick fix for this? Board with four columns — Needs you, Working, Ready for approval, Done — and a Home page that shows the same thing in short form: what needs me, what's working right now, and what got done today.

Every agent works in its own folder or its own git worktree, so parallel agents in the same repo don't trip over each other. When one is done, I look at its changes and combine them, or send them back with a note. Out-of-the-box.

Real work comes as epics: ticket B can't start until A is merged, and C and D can run in parallel after that. I used to keep that graph in my head and start each agent by hand at the right moment.

Then I thought, why don't I import a project into Switchboard for the delivery management? So I've made a module that is importing the Jira epic as a project. The tickets become steps in a dependency graph, built from Jira's "Blocks" links plus what the project's agent proposes. Each step starts on its own, in its own worktree, as soon as the steps before it are combined, and its agent gets the whole ticket: description, acceptance criteria, sub-tasks, comments and links. The graph is live: working steps pulse, the critical path glows, and I can leave it full screen on a second monitor.

Not a JIRA project? I still can use the planning that the agents do when it comes to development of proof of concepts, small features that are not well described in the task management system, firstly figuring out all the technicalities and road-blockers, and then telling the agent to sketch out the project plan in Switchboard that I can follow.

Of course, we need to remember about the review - and that is something that is sometimes overwhelming when we are going to let the agents loose. It requires tremendous amount of time to go through the code the agents generate, as well as fine-tuning the main instructions for the agents before they even start looking into the solution development. We do still have our AGENTS.md / CLAUDE.md files in the solutions that harness the agents to some extent, but I want to be clear - if it's a bigger project, the first delivery is with flaws. It's our job to make sure that we are delivering good quality code - maybe that is something that I will look into as next step of Switchboard's development.

Running many agents means hitting usage limits, often in the middle of a chain of steps. I do have plenty of accounts - some of them are work accounts with subscriptions, some of them API-based, some of them from Claude, some of them from OpenAI, hell, some of the models I also run on my PC.

What worked for me was letting Switchboard hold several logins per AI engine. I pick which account agents use (overall, or per project), and when it runs out they switch to another automatically, with a note in the chat. It warns at a level I choose, and a message sent while an agent is paused for usage shows as "Paused — waiting for usage" instead of disappearing.

I have desktop, laptop, and also my Z Fold 7. Agents run on both the desktop and laptop. And sometimes the answer an agent needs is one tap, while I'm making coffee.

That is the point where I thought about, what if I can access Switchboard at any device within my own network?

I came up with the idea of pairing computers and phones over Tailscale, with no relay server. Paired computers see each other's agents, so one Needs-you queue covers both machines, and an agent can be moved from one computer to the other. A phone pairs with a QR code, installs as an app and gets push notifications when an agent needs me — and it can even update Switchboard on my other computers if I release an update and then forget to update one of my PCs or I am completely away on a roadtrip or wherever else.

Many agents means many build servers, test hosts and dev servers, and agents rarely clean up after themselves. After a day of parallel.NET and Node work, my laptop had pleeeenty of stale test servers, build servers idling, just easily eating up my RAM (which is kind of precious these days, wouldn't you say?:) ). I needed to make them stop behaving as Chrome tabs:D.

Therefore, I added tracking the processes each agent starts, even after they detach, and showing them per agent with Stop and Keep. An agent's leftovers are stopped when it's closed or has been idle for ten minutes, never while it works and never one I chose to keep.

A related lesson: agents repeat each other's mistakes because they don't share what they learned. Switchboard has Notes ("What agents know"): an agent can propose a note, and nothing reaches the other agents until I approve it. A weekly background check removes notes the code has made untrue. Making that deliberate, instead of letting every agent write to a shared memory, kept the notes short and correct.

Switchboard is a local web app: one Node.js process on 127.0.0.1 that runs the unmodified claude, codex and opencode CLIs with your own logins. There's no account and no telemetry. It isn't a new agent or a new model, and it doesn't replace your editor.

Some parts of this already exist elsewhere, and you should use what fits you. Claude Code has its own agent view for background sessions on one machine. There are good desktop apps for parallel agents on a Mac, kanban-style tools, and mobile clients. Switchboard is my answer for a specific combination: several engines, several computers, a phone, Jira-driven ordering, and nothing leaving my machines except the agents' own traffic.

I know that there are plenty of tools that could probably achieve the same goals, but...

well - I thought that it would be fun to create a tailored environment for myself from scratch, especially having all of the possibilities and tools that are out there, including AI agents. But seemingly, it grew to something bigger, something also more generic as I am talking with fellow developers that can be tailored within their own working environments. Therefore the decision - I want to make my share for the open-source community and share that tool with you. Take a look, have a blast, critique, provide feedback - all open for that.

If, with that solution, I can help 1 person, that'd be a great milestone for me:)

npx @marcingadomski94/switchboard Enter fullscreen mode Exit fullscreen mode Or macOS and Linux:

curl -fsSL https://raw.githubusercontent.com/MarcinGadomski94/switchboard/master/install.sh | sh Enter fullscreen mode Exit fullscreen mode Windows (PowerShell): irm https://raw.githubusercontent.com/MarcinGadomski94/switchboard/master/install.ps1 | iex

It needs Node.js 24+, git, and at least one agent CLI signed in: Claude Code, Codex CLI or OpenCode. The installers check the release's SHA-256, never use sudo and don't touch your shell profile. Then open http://127.0.0.1:13001 and the setup wizard takes it from there.

Run many Claude Code, Codex and OpenCode agents at once. See what each one is doing and answer them from anywhere, even your phone.

Get started · macOS, Linux and Windows · MIT

Switchboard 2 opens in a new look, the v2 theme, with plain words instead of jargon (agents, tasks, projects, results; the glossary …