Emdash: Run Multiple AI Coding Agents in Parallel for Faster Development

Core Question: How can developers simultaneously manage multiple AI coding assistants to accelerate their development workflow?

In modern software development, AI coding assistants have become indispensable tools for developers. But have you ever faced this frustration: wanting to use Claude Code, Codex, Qwen Code, and other AI assistants simultaneously, yet having to switch back and forth between different terminal windows? Emdash was built specifically to solve this problem.

Emdash is a provider-agnostic desktop application that allows you to run multiple coding AI agents in parallel, with each agent isolated in its own git worktree. You can run these agents locally or execute them on remote machines via SSH. We call it an Agentic Development Environment (ADE).

This tool currently supports 21 CLI agents (and the number keeps growing), including mainstream choices like Claude Code, Qwen Code, Amp, and Codex. You can directly pass tickets from Linear, GitHub, or Jira to AI agents, review code diffs, test changes, create pull requests, view CI/CD check results, and even merge code directly.

Why Run Multiple AI Coding Agents in Parallel?

Core Question: What value does using multiple AI assistants simultaneously bring to real development scenarios?

Imagine this scenario: you’re developing a complex microservices architecture project. For frontend component optimization, you find Claude Code’s understanding capability stronger; for database query optimization, Codex often provides more precise suggestions; and for code security audits, you trust Qwen Code’s judgment more.

In the past, you would need to:

Open one terminal and launch Claude Code to handle frontend issues
Open another terminal to run Codex for database optimization
Open yet another terminal to use Qwen Code for security checks
Manually manage context and git status across different AI assistants
Carefully avoid code conflicts between different agents

Emdash changes all of this. It creates independent git worktrees for each AI agent, ensuring they don’t interfere with each other. You can distribute tasks to three AI assistants simultaneously, then review their work成果 in a unified interface.

Even more powerful, Emdash supports connecting to remote machines via SSH/SFTP. This means you can manage AI agents locally while having them work on actual production environments or development servers. Emdash supports SSH agent and key authentication, securely storing credentials in your operating system’s keychain.

Quick Installation: Comprehensive Three-Platform Coverage

Core Question: How can you quickly install and launch Emdash on different operating systems?

For macOS Users

If you’re using an Apple Silicon Mac, download the ARM64 version. For Intel processor Macs, choose the x64 version.

The most convenient way is using Homebrew:

brew install --cask emdash

This command automatically handles all dependencies and configuration, making it the most recommended installation method.

For Windows Users

Windows users have two options:

Installer version: Suitable for regular installation, automatically creates desktop shortcuts and Start menu items
Portable version: No installation required, extract and run immediately, perfect for USB drives or scenarios requiring frequent migration

Both versions are x64 architecture. Simply download and run to get started.

For Linux Users

Linux distribution users can choose:

AppImage: Works with most Linux distributions, make executable and run directly
Debian package: Suitable for Debian, Ubuntu, and their derivatives

# For Debian/Ubuntu users
sudo dpkg -i emdash-x64.deb
sudo apt-get install -f  # Run this if there are dependency issues

After installation, the first launch of Emdash will guide you through basic configuration. We recommend configuring your commonly used AI agents first, such as installing Claude Code or GitHub Copilot CLI.

Complete Landscape of Supported AI Coding Assistants

Core Question: Which AI coding assistants does Emdash support, and how do you install and configure them?

Emdash currently supports 21 CLI providers, and the team continuously adds new support. Here’s the complete support list:

AI Agent	Installation Command
Amp	`npm install -g @sourcegraph/amp@latest`
Auggie	`npm install -g @augmentcode/auggie`
Charm	`npm install -g @charmland/crush`
Claude Code	`curl -fsSL https://claude.ai/install.sh \| bash`
Cline	`npm install -g cline`
Codebuff	`npm install -g codebuff`
Codex	`npm install -g @openai/codex`
Continue	`npm i -g @continuedev/cli`
Cursor	`curl https://cursor.com/install -fsS \| bash`
Droid	`curl -fsSL https://app.factory.ai/cli \| sh`
Gemini	`npm install -g @google/gemini-cli`
GitHub Copilot	`npm install -g @github/copilot`
Goose	`curl -fsSL https://github.com/block/goose/releases/download/stable/download_cli.sh \| bash`
Kilocode	`npm install -g @kilocode/cli`
Kimi	`uv tool install --python 3.13 kimi-cli`
Kiro	`curl -fsSL https://cli.kiro.dev/install \| bash`
Mistral Vibe	`curl -LsSf https://mistral.ai/vibe/install.sh \| bash`
OpenCode	`npm install -g opencode-ai`
Pi	`npm install -g @mariozechner/pi-coding-agent`
Qwen Code	`npm install -g @qwen-code/qwen-code`
Rovo Dev	`acli rovodev auth login`

All listed agents have been tested and are fully supported. If you find a commonly used AI assistant missing, you can submit an Issue or Pull Request via GitHub.

Real-World Application: Multi-Agent Collaboration Workflow

Let me share a typical usage scenario. Suppose you’ve taken on a legacy codebase refactoring task:

Step 1: Code Quality Assessment
You first launch Claude Code to analyze architectural issues across the entire codebase and identify technical debt.

Step 2: Performance Optimization
Simultaneously, you have Codex focus on performance bottleneck analysis, particularly database queries and algorithm complexity.

Step 3: Security Audit
A third agent (like Qwen Code) handles scanning for potential security vulnerabilities and checking dependency CVE records.

Step 4: Integrated Decision-Making
Emdash displays the analysis results from all three agents side by side. You can see:

Claude Code suggests refactoring the user authentication module
Codex identifies N+1 query issues
Qwen Code discovers an outdated encryption library

Based on this information, you can prioritize tasks and have different agents handle the parts they excel at.

Ticket System Integration: Seamless Flow from Requirements to Code

Core Question: How do you directly pass tickets from project management tools to AI agents for processing?

Emdash supports deep integration with mainstream project management tools, including Linear, Jira, and GitHub Issues. This means you can directly transform tickets into AI agent tasks without manual copy-pasting of requirement descriptions.

Linear Integration

Core Question: How do you configure the Linear API and use it within Emdash?

The configuration process is straightforward:

Generate an API key in Linear settings
Paste this key in Emdash settings
Select the projects you want to sync

Once configured, you can browse Linear tickets directly in Emdash, select a ticket, click “Send to AI Agent,” and the ticket’s title, description, and acceptance criteria will be automatically passed to the AI.

Jira Integration

Core Question: How do you connect to Atlassian’s Jira system?

Jira configuration requires three pieces of information:

Your Jira site URL (e.g., yourcompany.atlassian.net)
Your Atlassian account email
Atlassian API token (needs to be generated in Atlassian account settings)

GitHub Issues Integration

Core Question: How do you authenticate via GitHub CLI and sync Issues?

GitHub integration requires installing GitHub CLI first:

# Install GitHub CLI (macOS example)
brew install gh

# Authenticate
gh auth login

After completing the OAuth process following the prompts, Emdash can access your GitHub repository Issues.

Practical Case: From Bug Report to Fix

Imagine this scenario: On a Friday afternoon, the testing team submits an urgent bug report on Linear. You open Emdash:

Find this bug ticket in the Linear panel
Click “Assign to Claude Code”
Claude Code reads the ticket description and automatically clones the relevant code branch
It analyzes error logs and locates the problem
Generates fix code and creates a git commit
You review the diff in Emdash
Create a GitHub Pull Request with one click
Wait for CI/CD checks to pass
Merge the code and close the ticket

Throughout this entire process, you don’t need to leave the Emdash interface or manually switch between different tools.

Remote Development: Running AI Agents on Servers

Core Question: How do you run AI coding assistants on remote servers via SSH?

Many development scenarios require working in remote environments:

Codebases are too large for local machine storage
Need to access intranet resources or databases
Remote servers have stronger computing power
Teams use unified development servers

Emdash’s SSH functionality perfectly supports these scenarios.

Configuring SSH Connections

Core Question: How do you securely configure remote server connections?

In Emdash, go to “Settings → SSH Connections” and add your server information:

Connection Method Selection:

SSH Agent (Recommended): If you’ve already configured an SSH agent in your terminal, Emdash can use it directly. Ensure your key is loaded:
```
ssh-add -l  # View loaded keys
ssh-add ~/.ssh/id_ed25519  # Add key to agent
```
Private Key File: Specify the private key file path, and Emdash will read and use it
Password Authentication: Enter server password (less secure, not recommended)

Adding Remote Projects

After configuring the SSH connection:

Click “Add Remote Project”
Select the SSH connection you just configured
Specify the code path on the server (e.g., /home/deploy/my-project)
Emdash will sync project metadata via SFTP

Best Practices for Remote Development

Scenario One: Production Environment Debugging

Your production server is experiencing a strange performance issue. Local reproduction is difficult due to different data scales. Using Emdash:

# On the remote server
cd /var/www/production-app

Add this path as a remote project in Emdash, then have Codex analyze performance logs from the production environment. The AI agent runs directly on the server, eliminating the need to download large log files.

Scenario Two: Team Collaboration Development Server

Your team shares a development server with a unified development environment. After configuring the SSH connection in Emdash:

Add remote project /srv/dev/team-project
Launch Claude Code for code review
Launch GitHub Copilot for programming assistance
All agents run on the server, using the server’s Git configuration and permissions

Remote Development Requirements

Ensure your remote server meets the following requirements:

Git is installed
You have SSH access
If AI agents need authentication (e.g., accessing private npm packages), ensure the SSH agent is running with the correct key loaded

Data Privacy and Local Storage

Core Question: How does Emdash store your data, and what privacy protection measures are in place?

Local-First Architecture

Emdash adopts a local-first design philosophy. All application state is stored in your local SQLite database:

Data Storage Locations:

macOS: ~/Library/Application Support/emdash/emdash.db
Windows: %APPDATA%\emdash\emdash.db
Linux: ~/.config/emdash/emdash.db

If you need to reset the application, simply close Emdash, delete this database file, and it will be recreated on the next launch.

Telemetry Data Explanation

Core Question: What usage data does Emdash collect, and how can you disable telemetry?

Emdash sends anonymous, allow-listed events to PostHog, including:

App start/close
Feature usage names (e.g., “Create SSH Connection,” “Add AI Agent”)
App version and platform information

Important Commitments:

Does not send code content
Does not send file paths
Does not send repository names
Does not send prompts
Does not send personally identifiable information (PII)

How to Disable Telemetry:

Method One: Disable in the app

Open Emdash
Go to “Settings → General → Privacy & Telemetry”
Toggle off telemetry

Method Two: Via environment variable

TELEMETRY_ENABLED=false emdash

Third-Party AI Agent Data Processing

It’s important to clarify: while Emdash itself doesn’t send your code or conversations to any servers, when you use AI agents (like Claude Code, Codex, Qwen, etc.), your code and prompts are sent to the respective providers’ cloud APIs for processing.

Each provider has its own data handling and retention policies. For example:

OpenAI’s Codex sends code to OpenAI servers
Anthropic’s Claude Code sends code to Anthropic servers
Google’s Gemini sends code to Google servers

Before using these tools, we recommend reviewing the respective providers’ privacy policies, especially if you’re handling sensitive code or proprietary algorithms.

Frequently Asked Questions

Core Question: What are the most common issues encountered when using Emdash, and how do you solve them?

Q1: Is GitHub CLI required?

Answer: No, it’s not mandatory. You only need to install it if you want to use GitHub-related features:

Creating pull requests from Emdash
Fetching repository information
GitHub Issues integration

If you don’t use these GitHub features, you can completely skip the gh installation.

Install and log in to GitHub CLI:

gh auth login

Q2: How do you add support for new AI agents?

Answer: Emdash is designed to be provider-agnostic and can quickly add new CLI tools.

If you want to add an unsupported AI agent:

Open an Issue on GitHub, providing the CLI link and typical commands
Or submit a Pull Request directly, including:
- Agent name
- Invocation method (CLI command)
- Authentication notes
- Minimal setup steps

The development team will add it to the integration matrix and connect the agent selection feature in the UI.

Q3: What should you do if you encounter native module crashes (sqlite3/node-pty/keytar)?

Answer: This usually happens after switching Node/Electron versions.

Quick fix steps:

Step One: Rebuild native modules

npm run rebuild

Step Two: If rebuilding fails, clean and reinstall

npm run reset

This command will:

Clean the node_modules directory
Reinstall dependencies
Rebuild Electron native dependencies

Q4: What permissions does Emdash require?

Answer: Emdash requires the following permissions:

Filesystem/Git permissions:

Read and write your code repositories
Create Git worktrees for agent isolation

Network permissions:

Only for AI agents you choose to use (like Codex, Claude, etc.)
Optional GitHub operations

Local database permissions:

Store application state in local SQLite

Important Note: Emdash itself does not send your code or chat content to any servers. Third-party CLI agents may transmit data according to their policies.

Q5: Can you sync Emdash configuration across multiple devices?

Answer: Currently, Emdash configuration is stored locally. If you need to use it on multiple devices, you can manually sync the database file:

# Backup configuration (macOS example)
cp ~/Library/Application\ Support/emdash/emdash.db ~/backup/

# Restore to new device
cp ~/backup/emdash.db ~/Library/Application\ Support/emdash/

We recommend adding this file to your cloud sync (like iCloud, Dropbox), but be careful not to run Emdash on two devices simultaneously to avoid database conflicts.

Q6: How do you completely uninstall Emdash and clean all data?

Answer: Complete uninstallation requires removing both the application and data:

macOS:

# Remove application
rm -rf /Applications/Emdash.app

# Remove data
rm -rf ~/Library/Application\ Support/emdash

Windows:

# Uninstall app via Control Panel
# Then delete data directory
Remove-Item -Recurse -Force "$env:APPDATA\emdash"

Linux:

# Remove app (depending on installation method)
sudo apt remove emdash  # If installed via deb

# Remove data
rm -rf ~/.config/emdash

Practical Operation Checklist

Five-Step Guide to Getting Started with Emdash:

Download and Install: Download the corresponding version for your operating system and install it
Install Your First AI Agent: We recommend starting with Claude Code or GitHub Copilot
```
curl -fsSL https://claude.ai/install.sh | bash
```
Configure Ticket System (Optional): If you use Linear, Jira, or GitHub Issues, configure API keys in settings
Add Your First Project: Click “Add Project” and select your code repository
Launch Parallel Agents: Select a project, simultaneously launch 2-3 different AI agents, and observe how they collaborate

Remote Development Configuration Checklist:

[ ] Install Git on the server
[ ] Generate SSH key pair (if you don’t have one)
[ ] Add public key to server’s ~/.ssh/authorized_keys
[ ] Test SSH connection: ssh user@server
[ ] Configure SSH connection in Emdash
[ ] Add remote project path
[ ] Test remote agent execution

Author Reflections and Unique Insights

During my use of Emdash, I’ve deeply appreciated the philosophical differences in tool design. Traditional development tools tend to follow the “one tool does one thing well” approach, while Emdash has chosen the path of “multiple tools working together.” This design reflects an understanding of the essence of AI coding assistants: AI is not meant to replace developers, but to enhance developers’ decision-making capabilities.

The most important lesson I’ve learned is that different AI agents indeed have different “personalities” and areas of expertise. Claude Code excels at understanding business logic, Codex has unique insights into algorithm optimization, and Qwen Code is more adept at handling Chinese comments and domestic technology stacks. Emdash’s value lies not simply in putting them together, but in providing a fair comparison platform that allows you to make choices based on actual output.

Another unexpected benefit is the cleverness of git worktree isolation. Initially, I thought this was just a technical implementation requirement, but in actual use, I discovered that this isolation actually encourages “experimental programming.” You can have one agent boldly refactor code while another conservatively optimizes performance, then compare results in a safe environment. Even if one agent’s suggestions are completely unusable, it won’t contaminate your main branch.

The remote development functionality opens another dimension of possibilities. With edge computing and distributed systems becoming increasingly prevalent today, being able to run AI agents near production environments rather than pulling all data locally—this “compute close to data” model may become the standard practice of the future.

Finally, I want to emphasize that while Emdash is powerful, it’s not a silver bullet. It’s best suited for scenarios where: you have clear development tasks, need suggestions from multiple perspectives, and are willing to spend time reviewing and integrating different approaches. If you just need to quickly generate boilerplate code, a single AI agent might be more efficient. But if you’re doing work that requires multi-dimensional thinking like architecture design, performance optimization, or security audits, Emdash’s parallel agent model will bring you unexpected value.

One-Page Quick Reference

Emdash Core Features:

✓ Run multiple AI coding assistants in parallel
✓ Each agent has independent git worktree
✓ Support for 21+ mainstream AI agents
✓ Local and remote SSH development
✓ Linear/Jira/GitHub Issues integration

Quick Installation Commands:

# macOS
brew install --cask emdash

# Disable telemetry
TELEMETRY_ENABLED=false

Essential Configuration:

Data storage: Local SQLite database
SSH authentication: SSH agent recommended
GitHub features: Requires gh auth login

Typical Workflow:

Add project → 2. Select AI agent → 3. Pass ticket → 4. Review diff → 5. Create PR

Privacy Points:

Emdash doesn’t send code to servers
AI agents send data to their respective clouds
Telemetry can be completely disabled

Troubleshooting:

npm run rebuild  # Fix native module issues
npm run reset    # Complete reset

Key Takeaways for Developers

Why Emdash Matters for Modern Development Teams:

The software development landscape has fundamentally changed with the advent of AI coding assistants. However, most developers still treat these tools as isolated utilities, missing the opportunity to leverage multiple perspectives simultaneously. Emdash addresses this gap by providing a unified environment where different AI agents can work in parallel on the same codebase.

The Parallel Development Advantage:

When you run multiple AI agents simultaneously, you’re not just speeding up development—you’re improving code quality through diverse perspectives. One agent might catch a security vulnerability another misses. One might suggest a more elegant architectural approach while another focuses on performance optimization. This multi-agent approach mirrors the code review process, but happens in real-time during development rather than after.

Getting Started Today:

The barrier to entry is remarkably low. With Homebrew on macOS, it’s a single command. The learning curve is gentle if you’re already familiar with Git and terminal-based development. Start with two agents you’re comfortable with, then gradually expand your toolkit as you discover which agents excel at which tasks.

The Future of AI-Assisted Development:

Emdash represents more than just a convenience tool—it’s a glimpse into the future of software development where human developers orchestrate multiple AI specialists rather than writing every line of code themselves. The developers who master this orchestration will have a significant productivity advantage.

Whether you’re a solo developer looking to amplify your output or a team lead wanting to establish best practices for AI-assisted development, Emdash provides the infrastructure to make parallel AI agent development not just possible, but practical and productive.