# Murmell

> A browser canvas where several AI coding agents — Claude Code, Codex, Kimi, OpenCode — run on a cloud machine and share one project directory. An agent claims a file before it writes to it, so several agents and several people work at once without overwriting each other.

Murmell opens Claude Code, Codex, Kimi and OpenCode inside windows on a dotted canvas, each window holding a real terminal. The agents run on cloud machines Murmell operates rather than on your laptop, so closing the tab does not stop them. You sign in with the agent subscriptions and API keys you already pay for; Murmell resells no tokens.

Several agents work in one project directory. Before an agent writes to a file it reserves the path, and one holder per file is enforced by the server rather than suggested to the model. A colliding write is snapshotted before it lands, so nothing is lost.

Several people can be on the same canvas at once, with named cursors. A guest sees the windows and reads the terminals as they scroll. Working alone is free; the shared canvas is the paid upgrade.

Work is pushed to a private repository created with the project, including one last push before a machine is torn down. The machine that executes agent code holds no database and no decryption key, so an agent that gets out of its sandbox finds nothing worth taking.

The name comes from murmuration. The same word means a murmur, which is also the shape of the mark: a wave.

## Start here
- [Murmell](https://murmell.com/): what the canvas is, and what happens when several agents share one directory.
- [Full text of the site](https://murmell.com/llms-full.txt): every page on murmell.com in one plain-text file, if you would rather read once than crawl.

## Explained
- [What is Murmell?](https://murmell.com/what/murmell): The short answer: what Murmell is, what you see, and what happens to the code.
- [A cloud sandbox for AI agents](https://murmell.com/what/cloud-sandbox-for-ai-agents): What the machine running agent code holds, and which secrets never reach it.
- [Multiple AI agents on one repo](https://murmell.com/what/multiple-ai-agents-one-repo): The file reservation board, and what two agents did with it when we watched.
- [Figma for developers](https://murmell.com/what/figma-for-developers): What the Figma analogy gets right about Murmell, and where it overreaches.
- [Claude Code in the browser](https://murmell.com/what/claude-code-in-the-browser): Claude Code in a browser tab, with nothing installed and the session outliving the tab.
- [Multiplayer coding with AI agents](https://murmell.com/what/multiplayer-coding-with-ai-agents): The two halves of multiplayer on Murmell: many agents, and many people watching them.
- [Run Claude Code in the cloud](https://murmell.com/what/run-claude-code-in-the-cloud): How Claude Code runs on a machine we operate instead of on your laptop.

## Compared
- [Murmell vs Codeg](https://murmell.com/vs/codeg): Aggregating local agent sessions against running the agents on one shared cloud directory.
- [Murmell vs Codex cloud](https://murmell.com/vs/codex-cloud): Why running the Codex CLI on a shared canvas is a different thing from delegating a task to it.
- [Murmell vs Conductor](https://murmell.com/vs/conductor): A Mac app with a workspace per task, against a cloud canvas with one directory for all of them.
- [Murmell vs GitHub Copilot and Agent HQ](https://murmell.com/vs/github-copilot): Where agent work converges: at the pull request, or in the working tree.
- [Murmell vs Cursor](https://murmell.com/vs/cursor): One editor per person and one VM per agent, against one canvas and one directory for everybody.
- [Murmell vs Devin](https://murmell.com/vs/devin): Parallel by separation against parallel by sharing, and when each shape is the right one.
- [Murmell vs Google Jules](https://murmell.com/vs/google-jules): A plan you approve and a pull request you review, against terminals you watch in one shared tree.
- [Murmell vs OpenHands Agent Canvas](https://murmell.com/vs/openhands): The closest comparison on the list: a worktree per agent against one tree with file reservations.
- [Murmell vs Replit Agent](https://murmell.com/vs/replit-agent): Building an app from nothing against running several agents on a codebase that already exists.
- [Murmell vs Vibe Kanban](https://murmell.com/vs/vibe-kanban): A kanban board over local agent runs, against a shared canvas over one cloud directory.

## Writing
- [Engineering notes from building Murmell](https://murmell.com/blog): The index of the engineering pieces.
- [What we found when we put agents on a cloud sandbox](https://murmell.com/blog/cloud-sandbox-findings): What a managed cloud sandbox platform allows and refuses, measured against a probe pool rather than read in a document.
- [What stops Claude Code on its first launch in a container](https://murmell.com/blog/claude-code-first-launch): The three prompts that block a fresh Claude Code agent in a container, measured through a real pty.
- [The machine that runs the agents holds no secrets](https://murmell.com/blog/machine-with-no-secrets): Why the half of the server that executes model-written code is kept away from the database, and what the separation cost to build.
- [Reserving a file before you write it](https://murmell.com/blog/reserving-a-file): Why several agents on one directory have to claim a path first, and what the server does when one of them does not.