Emdash: The Open-Source Tool That Runs Claude Code, Gemini, and Codex in Parallel (2026)

There's a quiet shift happening in how senior developers are building software in 2026. Instead of picking one AI coding assistant and sticking with it, they're running three, four, even nine agents at the same time — each one tackling a different slice of the same problem, then merging the best result.

The practice has a name now: agentmaxxing. And the tool that's making it accessible to the rest of us is Emdash, a YC W26-backed open-source desktop app that orchestrates parallel coding agents through isolated git worktrees. With 60,000+ downloads, 2,430 GitHub stars, and support for 31 different CLI agents, Emdash is betting that the future of AI development isn't one super-agent — it's a heterogeneous swarm.

This article breaks down what Emdash actually does, why git worktrees are the technical key that makes it work, how it compares to alternatives like Conductor and Claude Code's new Dynamic Workflows, and whether the multi-agent workflow is ready for your daily use.

What Is Emdash?

Emdash is an open-source Agentic Development Environment (ADE) — think of it as a control plane sitting above your existing CLI coding agents. You install the desktop app (it's built on Electron, runs on macOS, Windows, and Linux), connect a Git repository, and from there you can spawn multiple agents simultaneously. Claude Code in one pane. OpenAI Codex in another. Google Gemini in a third. Each one works on the same codebase, but inside its own isolated working directory.

The project lives at github.com/generalaction/emdash and is shipped under the MIT license. According to the Emdash homepage, the app supports 31 CLI-based agents at launch, including:

• Claude Code (Anthropic)
• OpenAI Codex
• Gemini CLI (Google)
• Cursor Agent
• Amp
• Cline
• Devin
• GitHub Copilot CLI
• OpenCode
• Qwen Code
• Droid
• ...and 20 more

The philosophy is straightforward, and it's the part that resonates with developers who've tried multiple tools. As StartupHub.ai put it in their YC W26 coverage: "The multi-agent future is heterogeneous. Developers will use Claude Code for some things, Gemini for others, Codex for others. What they need is an orchestration layer, not another agent."

The Git Worktree Trick That Makes It Work

The technical foundation underneath Emdash is git worktrees — a feature that's existed in Git since 2015 but has suddenly become essential in the AI era.

A worktree lets you check out multiple branches of the same repository into separate physical directories on disk, sharing the same .git storage. When you spawn three agents in Emdash, the app creates three worktrees behind the scenes. Agent A is editing files in /project-agent-claude. Agent B is editing in /project-agent-codex. Agent C is editing in /project-agent-gemini. None of them collide. None of them stomp on each other's changes.

This is why agentmaxxing finally works in 2026. As AddyOsmani.com notes in his deep dive on multi-agent coding: "The solution is giving each agent its own isolated branch, typically through Git worktrees, where each agent works in a separate directory with its own copy of the codebase."

When agents finish, Emdash gives you a diff view — three (or more) competing implementations side-by-side. You pick the winner, merge it back into main, and discard the rest.

How Emdash Compares to Other Multi-Agent Tools

Emdash isn't the only player in the parallel-agent space. Several tools launched in the first half of 2026 with overlapping goals. Here's how they stack up:

Emdash's main differentiator is breadth — 31 agents versus Conductor's 2-3 — combined with the fact that you can run it on a remote server over SSH. That second feature matters more than it sounds: if you're running long-horizon agents on a beefy cloud box overnight, you don't want them tied to your laptop's battery.

Anthropic itself moved in this direction in June 2026. According to InfoQ's reporting, Claude Code added Dynamic Workflows for parallel agent coordination, with one example workflow spawning nine agents in parallel to research different sources. The catch: it only orchestrates Claude. Emdash orchestrates everyone.

What Agentmaxxing Actually Looks Like

The word sounds like a joke, but the workflow is real. Daniel Vaughan's practitioner write-up on agentmaxxing describes a typical day:

1. Plan with one agent. Use Claude Code in plan mode to break a feature into 4-6 subtasks.
2. Fan out. Spawn Codex, Gemini, and a second instance of Claude Code on the trickiest subtask. Same prompt, different models.
3. Compare diffs. All three return implementations in 8-15 minutes. Look at the tests they wrote, the edge cases each one missed, and the readability of the code.
4. Cherry-pick. Take Claude's test suite, Codex's main logic, and Gemini's error handling. Stitch them into a single PR.
5. Move to the next subtask. While you're reviewing, the agents are already working on subtask #2.

Developers who've adopted this report 2-3× throughput gains on greenfield work, with the catch that code review becomes the bottleneck. You're no longer writing code — you're judging it. Some find that liberating; others find it exhausting after a few hours.

Installing and Running Emdash

Getting started is genuinely fast. From the Emdash docs:

# macOS (Homebrew)
brew install --cask emdash

# Or download the installer
# https://emdash.sh/download

Once installed, you'll need the CLI for each agent you want to orchestrate already installed and authenticated on your system. Emdash doesn't ship the agents themselves — it shells out to whatever's on your PATH. That keeps the binary small and means you pay your own API costs to Anthropic, OpenAI, or Google directly.

A minimal launch flow:

# 1. Install the agents you want
npm install -g @anthropic-ai/claude-code
npm install -g @openai/codex
npm install -g @google/gemini-cli

# 2. Open Emdash, point it at your repo
# 3. Click "New Task", paste your prompt, pick 3 agents
# 4. Watch them work in parallel

The diff view is where you'll spend most of your time. Each agent's changes show up as a side-by-side comparison against main, and you can selectively stage hunks from any of them into a final commit. It's essentially a four-way merge UI built for the AI era.

YouTube: Git Worktrees, the Feature Behind All of This

If you've never used git worktrees before, this 12-minute walkthrough explains the primitive that makes parallel coding agents possible.

When NOT to Use Emdash

Multi-agent orchestration is powerful, but it's the wrong tool for a lot of work. Don't reach for Emdash when:

• The task is small enough for one agent. Spawning three agents on a one-line fix is theater. Use a single CLI in your terminal and move on.
• You're learning a new codebase. Three different opinions from three different models is confusing when you haven't built your own intuition yet.
• You can't review the diffs carefully. Bad parallel agents produce bad PRs three times as fast. Only fan out when you have the time and energy to judge what comes back.
• API costs matter. Running Codex + Claude + Gemini on a single task multiplies your token spend by 3×. Worth it for high-stakes features, wasteful for routine work.

FAQ

Is Emdash free to use? Emdash itself is free and open-source under MIT. You pay each underlying AI provider (Anthropic, OpenAI, Google) directly for their API or CLI usage. No Emdash subscription exists.

Can I run Emdash on Windows? Yes. Emdash ships official installers for macOS, Windows, and Linux because it's built on Electron. The CLI agents you orchestrate (Claude Code, Codex, Gemini) also support all three platforms.

Do I need a beefy machine to run multiple agents in parallel? Not really — the agents are mostly network-bound, calling out to API servers. Your laptop is acting as a coordinator, not a compute host. 16 GB RAM is comfortable. The remote-SSH feature also lets you point Emdash at a cloud machine if you want.

How is Emdash different from Claude Code's Dynamic Workflows? Claude Code Dynamic Workflows orchestrates multiple instances of Claude internally. Emdash orchestrates different vendors' agents — Claude, Codex, Gemini, and 28 others. If you only ever use Claude, Dynamic Workflows is enough. If you want vendor diversity, Emdash is the layer above.

Will running agents in parallel actually save me time? For well-defined, isolated tasks: yes, often 2-3× on greenfield work. For exploratory work or learning a new codebase: probably not — review overhead eats the gains. The sweet spot is medium-complexity features where you want a second and third opinion before committing.

Conclusion

The single-agent era is ending. Not because any one model is bad, but because different models have different blind spots, and the cheapest way to cover them is to run several at once and pick the best output. Emdash is the first tool that makes this practice approachable for everyday developers without writing your own orchestration scripts in bash.

The real shift isn't the tool — it's the role. You're no longer the person typing code. You're the editor, the judge, the conductor. That's a different skill, and it's the one worth practicing this year.

The agents will keep getting better. The orchestrator that knows when to fan out and when to stay focused will still be you.