What is an agent multiplexer?

A "multiplexer" is a fancy technical term for something that lets you switch between inputs. There are multiplexers for terminal sessions, network connections, audio channels, and more.

Running several terminal sessions at once gets hard to manage, so you need a way to switch between them, arrange them, and keep them running after you disconnect.

The best-known terminal multiplexer is probably tmux. It gives you windows and panes for your sessions and lets you detach and reattach later. Tabbed terminal apps like Ghostty and macOS's Terminal.app are multiplexers too.

A terminal user interface, or TUI ("too-ee"), can draw menus, status lines, and interactive views inside a terminal.

Agent multiplexers and Git worktrees

Just as developers wanted to run multiple terminal sessions, now they want to run multiple coding agents. The first problem they run into is that agents can't share a single Git checkout. They trample on each other's changes because they share the same files, branch, and index.

The first generation of agent multiplexers used Git worktrees. Each agent gets its own working directory and branch while sharing the same repository.

These commands create two sibling worktrees on separate branches.

git worktree add -b github-issue-39393 ../github-issue-39393
git worktree add -b github-issue-40404 ../github-issue-40404

github-issue-39393                github-issue-40404
+-----------------------------+   +-----------------------------+
| Agent + Git worktree        |   | Agent + Git worktree        |
| Own files, branch, index    |   | Own files, branch, index    |
+-----------------------------+   +-----------------------------+
               |                                 |
               +----------------+----------------+
                                |
+---------------------------------------------------------------+
| Shared Git objects and refs                                   |
| Shared host processes, system packages, and ports              |
+---------------------------------------------------------------+

Agent multiplexers with sandboxes

Worktrees only separate working files. Processes, system packages, and network ports are still shared, so two agents can still try to start a dev server on the same port. Processes and temporary files from earlier tasks can also linger and interfere with later work.

The second generation of agent multiplexers also manages isolated execution environments. Each task gets its own sandbox and Git checkout.

github-issue-39393                github-issue-40404
+-----------------------------+   +-----------------------------+
| Container                   |   | Container                   |
|                             |   |                             |
| Agent + checkout            |   | Agent + checkout            |
| Own processes               |   | Own processes               |
| Own dependencies            |   | Own dependencies            |
| Own ports                   |   | Own ports                   |
+-----------------------------+   +-----------------------------+

An agent multiplexer brings those workspaces into one interface, so you can switch between agents and see what each one is doing.

Parallel agents in ephemeral workspaces

Ephemeral workspaces are an effective way to run more coding agents in parallel. Each task gets its own environment. When it's done, you keep the useful artifacts and conversation history, and throw away everything else. If an approach doesn't work out, discard the changes along with the workspace.

You can work fearlessly when deleting a workspace doesn't risk losing work or context.

Conversation history

Keep searchable transcripts of all agent conversations in a shared memory system. Agents can recover context after a workspace is deleted and check up on each other's progress across space and time, including sessions that are still running.

Files and artifacts

Push code to a Git remote and upload reports, images, and other artifacts to cloud storage before deleting the workspace. A later session can retrieve the files and use the conversation history to continue the work.

Learning to multiplex agents

Modern software development increasingly involves multiplexing agents. That takes new tools for managing their environments, context, and output, and new skills for dividing work into independent tasks, giving agents useful context, and reviewing what they produce.

It's easy to feel overwhelmed, but remember that everyone is still figuring this stuff out.

Running more agents is easy, but keeping them doing useful work and bringing their changes together takes practice. There's a lot of room to improve both the tools and how we use them.

The exciting part of learning to work this way is that it lets you be more ambitious.