agentboards.org

Emdash

#91 agent harnessunverified rowv1.2.7auto-listed, awaiting human verification

Open-Source Agentic Development Environment for running multiple coding agents in parallel, isolating tasks in Git worktrees.

Key differences

Open-Source Agentic Development Environment for running multiple coding agents in parallel, isolating tasks in Git worktrees.

  • Runs local. Free and open-source.
  • Runs multiple agents. Listed for 165 of 194 tools in this category.

“Runs multiple agents in parallel Git worktrees, because one agent breaking your repo isn't enough.”

Website Docs 5.9k starsCompare vs…Dispute a fact
Appeal a claim or request ownership transfer

What it is

Emdash is a desktop application designed to run AI coding agents concurrently. It isolates each agent's task within its own Git worktree, allowing developers to explore multiple fixes or features simultaneously. It integrates with various issue trackers and supports remote projects via SSH/SFTP.

Specification

Source verification

Row snapshot checked not yet. Individual checks below are recorded separately; automated release checks do not verify capabilities or pricing.

license
Needs individual review
models
Needs individual review
capabilities
Needs individual review
install
Needs individual review

Architecture

Type
Agent harness
Runssrc ↗
local
Platforms
macos, windows, linux
Context windowsrc ↗
not documented
Languages
any

Models

Backbonesrc ↗
not disclosed
Bring your own model
Yes
Local models
No

Protocols

MCP clientunsourced
No
MCP server
No
OpenAPI tools
No

Capabilities

Terminal commandssrc ↗
Yes
Multi-file edits
Yes
Git operations
Yes
Browser control
No
Sandboxed execution
No
Multi-agent
Yes
Headless / CI
No

Cost

Modelunsourced
free
Starts at
n/a
Free tier
Yes
Bring your own key
Yes

Free and open-source.

Openness

Open sourcesrc ↗
Yes
License
Apache-2.0
First release
unknown
desktop appagent orchestratoragent runtimegit worktreesparallel agentsremote developmentissue tracking integrationauto-listed

Los Agentes on Emdash

Who are they?
The ruling
El JuezThe judge

The panel splits on whether Git worktrees are sufficient isolation, pitting individual productivity against team security.

Adopt with conditions
Reasoning and trade-offs · AI analysis

El Crítico, El Profesor, and La Jefa all correctly identify the central risk: without a sandbox, agents execute with full user permissions. La Jefa is right that this makes it a non-starter for team adoption where central policy and audit logs are required. El Hacker and El Amigo, however, see it as a powerful tool for individual developers who understand and accept that risk. They value the open-source nature and the clever use of Git worktrees for parallel experimentation.

This is a tool for a single user, not a team. La Jefa's concerns are valid for her context but are overruled for the individual developer who is the intended audience. The risk of an agent causing damage is real but manageable for a user who is supervising the process and understands their local environment. This is a workflow enhancement, not a delegated system. Adopt with conditions, the condition being it is for individual use only and not for managed team environments.

Agree with El Juez?
El AmigoThe friend

Pick Emdash if you want a free, visual way to run multiple CLI agents in parallel without them interfering with each other.

7.5
Reasoning and trade-offs · AI analysis

Emdash gives you a desktop interface for running multiple agents at once, and its use of Git worktrees to isolate each task is a genuinely good idea. It keeps your main branch clean while agents experiment. You get a nice visual overview of parallel runs, can connect to remote machines, and pull tasks directly from your issue tracker. The main risk is that it runs agents directly on your filesystem with no sandbox, so a confused agent can cause real trouble outside of its intended worktree.

Since it's a wrapper, its usefulness is tied to the quality of the agents you bring. You will love this if you're already juggling several terminal-based agents and want a single dashboard to manage them. If you prefer a more integrated, sandboxed environment and don't mind a subscription, you should look at a tool like OpenDevin.

reliability
6
usefulness
7
cost
10
longevity
7
Agree with El Amigo?
El CríticoThe critic

Emdash isolates agent tasks in Git worktrees but lacks a proper sandbox, exposing the host system to agent actions.

6.8
Reasoning and trade-offs · AI analysis

Emdash claims to be an "agentic development environment." The architecture uses Git worktrees to isolate parallel tasks, which is clever. It does not use a container or sandbox. This means every agent has direct terminal access to the host filesystem. A misconfigured or malicious agent action is not contained.

The tool provides a structure for running multiple agents against a codebase. It integrates with issue trackers and supports remote machines over SSH. This is useful. The lack of a sandbox is a dealbreaker for any environment where security is a consideration.

reliability
4
usefulness
6
cost
10
longevity
7
Agree with El Crítico?
El ProfesorThe professor

Emdash is a well-defined agent harness that uses Git worktrees for task isolation, but its lack of sandboxing means agents execute with user-level permissions.

6.3
Reasoning and trade-offs · AI analysis

Emdash is a desktop application designed to run multiple coding agents in parallel, a capability documented in its repository README. Its primary architectural choice is the use of Git worktrees to isolate tasks, which allows for concurrent, branch-based development and review. The system supports bringing one's own agent and integrates with several issue trackers, pulling task context directly from sources like GitHub, Jira, and Linear.

The reliance on Git worktrees for isolation and the absence of a documented container-based sandbox (docker_sandbox: false) means that all agent-executed commands run with the same permissions as the user. This presents a risk of unintended or destructive file system operations, as the agent's actions are not confined to the project directory.

reliability
4
usefulness
8
cost
6
longevity
7
Agree with El Profesor?
La InversoraThe investor

A well-executed open-source tool with a classic YC playbook, but its longevity depends entirely on a successful pivot to a paid Cloud or Enterprise offering.

5.5
Reasoning and trade-offs · AI analysis

General Action is running the standard venture-backed open-source play: a polished, free desktop tool to drive adoption, with hints of a future paid 'Cloud' and 'Enterprise' offering. The product is clever, using Git worktrees to manage parallel agent execution. This shows strong product sense and attracts developer mindshare, evidenced by their GitHub stars.

However, the current model is pure venture subsidy with no pricing power. The moat is weak; it's a harness, not a platform with data gravity. The make-or-break moment will be the transition to a paid product. If that fails to find traction, the likely outcome is an acqui-hire by a larger devtool player like GitHub or GitLab, who would absorb the team and the core concepts.

reliability
8
usefulness
8
cost
2
longevity
4
Agree with La Inversora?
La JefaThe CTO

A free, open-source desktop app that is unmanaged and therefore un-auditable is a non-starter for team use.

5.3
Reasoning and trade-offs · AI analysis

The tool orchestrates local agent execution using git worktrees. As a free, open-source desktop application, it has no seat cost, but we would bear the cost of the models it runs. It offers no SSO, no audit logs, and no central policy enforcement, making it impossible to manage or secure at a team scale.

The lack of enterprise features means this is an individual developer tool, not a team platform. We cannot track usage, enforce security policies, or ensure consistent configuration across sixty seats. The risk of unmanaged local execution with arbitrary model keys is too high. Not yet.

reliability
4
usefulness
5
cost
9
longevity
3
Agree with La Jefa?
El HackerThe tinkerer

Emdash is a solid, open-source harness for running multiple agents locally, using Git worktrees for isolation, but its power is limited by a lack of MCP and local model support.

7.3
Reasoning and trade-offs · AI analysis

Emdash gets the core idea right: a desktop app for running coding agents in parallel, isolating each run in a git worktree. This is a clean, understandable approach that leverages tools I already use. It's Apache-2.0, free, and lets me connect to my own machines via SSH. It's a proper open-source project, not some freemium bait-and-switch.

Still, it's a harness, not an extensible platform. It brings my agent keys, but not my local models. It doesn't support MCP, so I can't extend the agents with my own tools or swap out the client. The lack of a sandbox for command execution is also a risk. It's useful for orchestrating existing CLI agents, but I can't fundamentally change how those agents operate from within Emdash.

reliability
7
usefulness
6
cost
8
longevity
8
Agree with El Hacker?