Explained

AI coding agents, sorted by what separates them

Thirteen tools put AI agents to work on code, and the question that actually separates them is this: when you start a second one, where does it go? There are three answers, a cloud machine of its own, a workspace on your disk, or the same directory as the first, and everything else follows from that.

The question that sorts the field

All of these tools can start an agent. The first one is easy: it reads, it writes, it runs the tests. The designs diverge at the second, because somebody has to decide what it sees and what it is allowed to touch.

The table below ranks nothing: it says who each tool is for, one line per tool, and the groups underneath explain why.

Which to take, one line each

The table on the comparisons page asks the other question, the one about where a second agent goes.

A cloud machine of its own, per task

The agent gets a clone of your repository on a machine you never see, works on a branch and hands back a pull request. It is the most common shape and the one that asks for the least trust: nothing it does touches your checkout before you have read the diff.

• Cursor. One editor per person and one VM per agent, against one canvas and one directory for everybody.
• Devin. Parallel by separation against parallel by sharing, and when each shape is the right one.
• Jules. A plan you approve and a pull request you review, against terminals you watch in one shared tree.
• Copilot and Agent HQ. Where agent work converges: at the pull request, or in the working tree.
• Codex cloud. Why running the Codex CLI on a shared canvas is a different thing from delegating a task to it.
• Replit Agent. Building an app from nothing against running several agents on a codebase that already exists.

A workspace per task, on your own machine

The same choice, at home: a git worktree or a working directory per agent, and a merge at the end. The code never leaves, which settles the security conversation before it starts, and nobody else sees the session.

• Windsurf. A worktree per conversation on your own machine, against one shared directory in the cloud.
• Conductor. A Mac app with a workspace per task, against a cloud canvas with one directory for all of them.
• OpenHands Agent Canvas. The closest comparison on the list: a worktree per agent against one tree with file reservations.
• Vibe Kanban. A kanban board over local agent runs, against a shared canvas over one cloud directory.
• Codeg. Aggregating local agent sessions against running the agents on one shared cloud directory.

One agent at a time, in your editor

No documented parallelism: one supervised agent, in the tool where you write. It is the best trade when you are the one holding the keyboard and the agent is assisting you.

• Gemini Code Assist. One supervised agent in your editor, against several unsupervised ones in a directory you watch.

The same agent, somewhere else

The CLI is identical on both sides. What changes is the machine it runs on and how many people can watch it.

• Claude Code on the web. The same CLI in two places: one isolated VM per task, against several agents on one canvas and one checkout.

The shared directory, and why almost nobody offers it

There is a fourth answer missing from the table, and it is ours: several agents in one directory, with no copies. Almost nobody offers it because it needs an arbiter. Without one, two agents read the same version of a file and the second erases the first with nothing to announce it.

Murmell puts that arbiter in the server. An agent announces the paths it is about to touch before it writes, the board hands them over, and refuses everybody else until it lets go. A write that lands on a file somebody else holds is snapshotted before it lands. The mechanism in full.

How to choose in two minutes

If you write the code yourself, take an editor: Cursor, Windsurf or Gemini Code Assist, and the question is settled. If your tasks are independent and you want to hand them over, take a cloud agent: Devin, Jules or Codex cloud. If the code is not allowed to leave your network, take something local and open source, OpenHands first.

One case is left, and it is the only one Murmell is built for: several agents that have to touch the same files in the same hour, with people watching. The comparisons, one at a time.

Straight answers