Emdash: The Open-Source IDE Built to Run 22 Coding Agents in Parallel
The first generation of AI coding tools shipped one agent per editor. Copilot in your IDE, Cursor as the IDE, Codex in a CLI, Claude Code in a terminal. You picked a side and lived with it. Anyone who's actually worked with multiple coding agents knows the truth: they're complementary, not interchangeable. Claude is better at one thing, Codex at another, Qwen at a third — and the workflow of juggling them is currently held together with terminal tabs and prayers.
Emdash wants to be the layer above that mess. It's a free, open-source desktop app — Y Combinator W26, MIT-licensed — that lets you run 22 different CLI coding agents in parallel, each isolated in its own git worktree, on your laptop or on a remote server over SSH. Its creators, Arne Strickmann and Raban von Spiegel, call the category an Agentic Development Environment, or ADE.
The repo at generalaction/emdash has 2.4k stars and 3,246 commits on main as of this writing, with 83 releases shipped since launch. The latest, v0.4.27, dropped on March 7, 2026.
The core idea: git worktrees, not threads
Most "multi-agent" tools either run one agent at a time and call themselves multi-agent, or run agents in shared workspace state and let you sort out the conflicts. Emdash does neither. When you assign a task to an agent, the app spins up a git worktree — a full working copy of the repo that shares the same .git directory but lives in a separate folder on disk.
That single design choice is what unlocks honest parallelism. Two agents can modify the same file in the same repo at the same time, because they're not actually sharing the file. Each one sees its own copy, makes its own changes, and produces its own diff. You review them independently and decide which to merge.
The core technical insight is git worktrees. A full copy of your working tree that shares the same
.gitdirectory but lives in its own directory on disk. Two agents can modify the same file in the same repo at the same time without conflicts.
For anyone who has tried to run two coding agents against the same repo in parallel using nothing but git stash, this is the obvious right answer.
22 CLI providers, one orchestration surface
Emdash's provider list is the closest thing the field has to a state-of-the-CLI-agent census. From the README:
| Provider | Install command |
|---|---|
| Claude Code | curl -fsSL https://claude.ai/install.sh | bash |
| Codex | npm install -g @openai/codex |
| Gemini | npm install -g @google/gemini-cli |
| GitHub Copilot | npm install -g @github/copilot |
| Cursor | curl https://cursor.com/install -fsS | bash |
| Qwen Code | npm install -g @qwen-code/qwen-code |
| Amp | npm install -g @sourcegraph/amp@latest |
| OpenCode | npm install -g opencode-ai |
| Kilocode | npm install -g @kilocode/cli |
| Goose | curl -fsSL https://github.com/block/goose/releases/download/stable/download_cli.sh | bash |
The full list also includes Auggie, Autohand Code, Charm Crush, Cline, Codebuff, Continue, Droid (Factory), Kimi, Kiro, Mistral Vibe, Pi, and Rovo Dev — 22 active integrations in total, with new ones added regularly via PRs.
The point isn't that you'll ever run all 22. The point is that adding the 23rd is a CONTRIBUTING.md task, not an architecture change. Emdash decouples the agent from the workflow.
Ticket-to-PR loop
Emdash doesn't just dispatch agents — it closes the loop. You can paste a Linear, GitHub Issues, or Jira ticket directly into the app, hand it to an agent, then review the diff, run tests, push the branch, see CI/CD status, and merge — all from the same window. Authentication is straightforward:
- Linear — connect with an API key
- Jira — site URL, email, and Atlassian API token
- GitHub Issues — authenticate via
gh auth login
It's a small detail but it's the right one. Most "agent IDEs" stop at "here's a diff." Emdash stops at "here's a merged PR with passing checks."
Remote development over SSH
The feature that quietly makes Emdash usable on real codebases is SSH-backed remote work. You add a remote machine in Settings → SSH Connections, point the app at a project path on the server, and run agents against the remote codebase using the same parallel-worktree workflow.
Auth supports SSH agent (recommended), private keys, or password, with credentials stored in your OS keychain. Requirements are the obvious ones: SSH access, git installed on the server, and your SSH agent loaded with a key. For developers who do most of their real work on cloud dev boxes, this is the difference between "fun toy" and "default editor."
Privacy posture
A few details worth flagging for anyone evaluating Emdash for serious use:
Data location. App state lives in a local SQLite database — ~/Library/Application Support/emdash/emdash.db on macOS, %APPDATA%\emdash\emdash.db on Windows, ~/.config/emdash/emdash.db on Linux. Quit the app, delete the file, you're reset.
What Emdash itself sends. Per the FAQ: anonymous, allow-listed telemetry to PostHog — app start/close events, feature usage names, platform versions. No code, file paths, repo names, prompts, or PII. You can disable it in Settings → General → Privacy & Telemetry, or by setting TELEMETRY_ENABLED=false before launch.
What the agents send. This is where reasonable people should pay attention. Emdash is provider-agnostic, but the providers themselves are not. When you point Claude Code, Codex, or Qwen at a file, that file content goes to the provider's API. Emdash doesn't proxy it. Read each CLI's data handling policy before pointing it at anything sensitive.
Installation
Direct downloads from the latest releases page:
- macOS (Apple Silicon):
emdash-arm64.dmg - macOS (Intel x64):
emdash-x64.dmg - Windows (installer):
emdash-x64.msi - Linux (AppImage):
emdash-x86_64.AppImage - Linux (Debian):
emdash-amd64.deb
For Homebrew users:
brew install --cask emdash
Once installed, point it at an existing local repo or wire up an SSH connection, install whichever CLI agents you actually want to drive, and you're off.
Who this is for
If you only use one coding agent today, Emdash is overkill — stick with whatever wrapper your provider ships. If you've spent the last few months alternating between Claude Code in one terminal and Codex in another, fighting with git stash, and wishing you could just dispatch two tasks to two models and review the diffs side by side, Emdash is the tool the workflow has been waiting for.
The honest competitive picture: Vercel's Open Agents and Google's Antigravity are circling the same problem from the cloud side. Emdash's bet is that the right surface for orchestration is local-first and provider-neutral — closer to a desktop git client than to a hosted IDE. Whether that bet pays out depends on how many developers actually want to host the orchestration themselves.
The Bottom Line
Emdash is the cleanest implementation we've seen of a workflow that has been quietly inevitable since the second serious coding agent shipped: multiple agents, in parallel, on the same code, with real isolation. It's free, it's MIT-licensed, the architecture is sane, and the provider list is real.
It is not a silver bullet for AI-assisted engineering — none exists — and it does not make the underlying agents any smarter. What it does is remove the worst parts of the current workflow, the parts that have nothing to do with the model and everything to do with terminal-tab math. That alone earns it a spot on the dock.
