murmell.com

mx

aspmx.l.google.com

alt1.aspmx.l.google.com

alt2.aspmx.l.google.com

alt4.aspmx.l.google.com

alt3.aspmx.l.google.com

ns

nina.ns.cloudflare.com

cosmin.ns.cloudflare.com

caa

txt

ms-domain-verification=0b0dbde1-b636-41db-ad94-32494c7e5fa7

google-site-verification=XOvxxH5W3EsrzaTw8dU-xZTfNGC22HHbagUiMKcqB4c

v=spf1 include:_spf.google.com include:spf.protection.outlook.com ~all

google-site-verification=279OGqDMBIflsK-QLhL1pdv0CH4UrrqRuFnZgA1kzdg

dmarc

v=DMARC1; p=quarantine; pct=100; rua=mailto:mossab@murmell.com; adkim=r; aspf=r

# Everything on murmell.com is public and meant to be read, by people and by
# machines, except private workspace and authentication paths.

User-agent: *
Allow: /
# Private workspace routes and internal auth endpoints
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: GPTBot
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: OAI-SearchBot
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: ChatGPT-User
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: ClaudeBot
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: Claude-Web
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: Claude-SearchBot
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: Claude-User
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: anthropic-ai
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: PerplexityBot
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: Perplexity-User
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: Googlebot
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: Google-Extended
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: GoogleOther
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: Google-InspectionTool
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: Applebot
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: Applebot-Extended
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: Bingbot
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: BingPreview
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: meta-externalagent
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: Meta-ExternalFetcher
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: FacebookBot
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: Amazonbot
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: CCBot
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: Baiduspider
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: Baiduspider-render
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: YandexBot
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: cohere-ai
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: Diffbot
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: Bytespider
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: DuckDuckBot
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: DeepSeekBot
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: GrokBot
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: MistralBot
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

User-agent: TavilyBot
Allow: /
Disallow: /p/
Disallow: /p/*
Disallow: /cli-auth
Disallow: /cli-auth/*
Disallow: /demo
Disallow: /demo/*

Sitemap: https://murmell.com/sitemap.xml

# 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. A read link costs the viewer nothing and needs no account; sharing a canvas somebody else can drive is what the plan pays for.

Starter is $0.99 per month with Limited Murmell Cloud, equal to 30 minutes per day, and 1 GB shared storage. Go is $9 per month with 10x Murmell Cloud, equal to 5 hours per day, and 5 GB. Pro is $39 per month with Unlimited Murmell Cloud and 20 GB. Storage is shared across all Canvases in the subscription. Every plan includes one active Canvas and 20 agent windows. Annual billing saves 20%. Provider usage is billed separately. Contact us for Enterprise.

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.
- [Feed](https://murmell.com/feed.xml): the articles, newest first, for checking what is new without refetching the site.
- [Agents IA de code dans le cloud](https://murmell.com/fr): the same product in French, with the French pages under it.
- [云端 AI 编程代理](https://murmell.com/zh): the same product in Chinese, with the Chinese pages under it.
- [Agentes de IA de código en la nube](https://murmell.com/es): the same product in Spanish, with the Spanish pages under it.
- [Agentes de IA de código na nuvem](https://murmell.com/pt): the same product in Portuguese, with the Portuguese pages under it.
- [KI-Coding-Agenten in der Cloud](https://murmell.com/de): the same product in German, with the German pages under it.
- [Agenti IA di coding nel cloud](https://murmell.com/it): the same product in Italian, with the Italian pages under it.
- [クラウドで動くAIコーディングエージェント](https://murmell.com/ja): the same product in Japanese, with the Japanese pages under it.
- [클라우드에서 실행되는 AI 코딩 에이전트](https://murmell.com/ko): the same product in Korean, with the Korean pages under it.
- [ИИ-агенты для кода, работающие в облаке](https://murmell.com/ru): the same product in Russian, with the Russian pages under it.
- [क्लाउड में कोड लिखने वाले AI एजेंट](https://murmell.com/hi): the same product in Hindi, with the Hindi pages under it.

## Agents
- [AI Coding Agents in the Cloud: Supported Agents on Murmell](https://murmell.com/agents): Overview of supported AI coding agents running in persistent cloud sandboxes on Murmell.
- [Claude Code Multi-Agent Cloud: Run Claude Code in the Cloud](https://murmell.com/agents/claude-code-cloud): Run Anthropic Claude Code in a persistent cloud sandbox with multi-agent file locking and zero local setup.
- [Codex in the Cloud: Persistent Cloud Runner for OpenAI Codex](https://murmell.com/agents/codex-cloud): Run OpenAI Codex in a persistent cloud runtime with real-time file locking and zero local setup.

## Features
- [Murmell Features: Multi-Agent Canvas, File Locking, Cloud Sandboxes](https://murmell.com/features): Core capabilities of Murmell for multi-agent cloud coding and real-time collaboration.
- [Multi-Agent Canvas: AI Agent File Lock Canvas for Parallel Coding](https://murmell.com/features/multi-agent-canvas): A real-time visual canvas with file reservation locks for parallel AI coding agents.

## Explained
- [Murmell explained, one page per idea](https://murmell.com/what): The index of the explanation pages, from what Murmell is to what the sandbox holds.
- [What is Murmell? Several coding agents in one repository](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.
- [AI agent file locking: Preventing multi-agent race conditions](https://murmell.com/what/ai-agent-file-locking): How server-enforced file locking and collision snapshots enable multiple AI agents to safely write to one repository.
- [Cloud AI for developers: models, APIs and remote coding agents](https://murmell.com/what/cloud-ai): The three senses of cloud AI, and the one that matters if you want a machine to write code.
- [Cloud AI coding agents: how remote agents work on a repository](https://murmell.com/what/cloud-ai-agent): What a coding agent running on a remote machine actually does, and what it needs to start.
- [Figma for developers: a multiplayer canvas for code](https://murmell.com/what/figma-for-developers): What the Figma analogy gets right about Murmell, and where it overreaches.
- [The words Murmell uses, defined](https://murmell.com/what/glossary): Every term the product uses, defined in a sentence each.
- [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.
- [AI coding agents, sorted by what separates them](https://murmell.com/what/best-ai-coding-agents): The field of AI coding agents, sorted by where each tool sends a second agent.

## Guides
- [Guides: putting coding agents to work](https://murmell.com/how): The index of the guides, in numbered steps, from the first agent to a shared session.
- [How to use Claude Code without installing anything](https://murmell.com/how/use-claude-code-without-installing): The steps for opening a real Claude Code terminal from a browser, with no local installation.
- [How to coordinate Claude Code and Codex on one project](https://murmell.com/how/coordinate-claude-code-and-codex): How to divide tasks between Claude Code and Codex on a shared Murmell canvas with real-time file reservations.
- [How to run several AI agents on one project](https://murmell.com/how/run-several-ai-agents): The steps for running several coding agents on one shared directory, from empty project to splitting the files.
- [How to show a coding session live](https://murmell.com/how/share-a-coding-session): The steps for letting a colleague or a client watch an agent session live, with nothing but a link.

## Compared
- [Murmell compared, tool by tool](https://murmell.com/vs): The index of the comparison pages, grouped by where each tool puts a parallel agent.
- [Murmell vs Claude Code on the web](https://murmell.com/vs/claude-code): The same CLI in two places: one isolated VM per task, against several agents on one canvas and one checkout.
- [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 Gemini Code Assist](https://murmell.com/vs/gemini-code-assist): One supervised agent in your editor, against several unsupervised ones in a directory you watch.
- [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.
- [Murmell vs Windsurf](https://murmell.com/vs/windsurf): A worktree per conversation on your own machine, against one shared directory in the cloud.

## Writing
- [Engineering notes from building Murmell](https://murmell.com/blog): The index of the engineering pieces.
- [Codex on your laptop, Codex in the cloud, and a third place](https://murmell.com/blog/codex-on-your-laptop-and-in-the-cloud): Why choosing between the Codex CLI and Codex cloud is a question about who is watching, not about how much compute you want.
- [What a link has to carry to share a live coding session](https://murmell.com/blog/sharing-a-live-coding-session): The three things a share link has to carry, and why the live preview behind it is the part that is easy to get dangerously wrong.
- [Watching a terminal you do not host](https://murmell.com/blog/watching-a-terminal-you-do-not-host): What it takes to keep a browser attached to an agent running on somebody else’s machine, and the two things that break silently when it is done carelessly.
- [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.

## About
- [Who builds Murmell](https://murmell.com/about/founders): The two people behind Murmell, their own sites, and the other products they run.

## Legal
- [Murmell Claude credits draw rules](https://murmell.com/legal/product-hunt-contest): Official rules for the Murmell Product Hunt launch draw for one transferable award of $1,000 in Claude credits.
- [Legal notice](https://murmell.com/legal/notice): Who publishes and hosts Murmell, and how to contact us.
- [Privacy at Murmell](https://murmell.com/legal/privacy): What is stored, what is not, and which machine holds which secret.
- [Terms of service and sale](https://murmell.com/legal/terms): Service rules, Murmell Cloud plans, cancellation, ownership, and responsibility.

## En français

> Un canvas dans le navigateur où plusieurs agents IA de code (Claude Code, Codex, Kimi, OpenCode) tournent sur une machine cloud et partagent un même dossier de projet. Un agent réserve un fichier avant d'y écrire, donc plusieurs agents et plusieurs personnes travaillent en même temps sans s'écraser.

- [Agents IA de code dans le cloud : agents compatibles](https://murmell.com/fr/agents): Vue d'ensemble des agents IA de code exécutés dans des environnements cloud persistants sur Murmell.
- [Claude Code dans le cloud : exécuter Claude Code en ligne](https://murmell.com/fr/agents/claude-code-cloud): Exécutez Anthropic Claude Code dans un bac à sable cloud persistant avec verrouillage de fichiers multi-agents.
- [Codex dans le cloud : exécution persistante d'OpenAI Codex](https://murmell.com/fr/agents/codex-cloud): Exécutez OpenAI Codex dans un runtime cloud persistant avec réservation de fichiers en temps réel.
- [Fonctionnalités de Murmell : canvas multi-agents et réservation de fichiers](https://murmell.com/fr/features): Capacités principales de Murmell pour le développement multi-agents dans le cloud et la collaboration en direct.
- [Canvas multi-agents : espace visuel et verrouillage de fichiers](https://murmell.com/fr/features/multi-agent-canvas): Un canvas visuel temps réel avec verrouillage de fichiers pour exécuter des agents IA en parallèle.
- [Comprendre l'IA de code dans le cloud](https://murmell.com/fr/quoi): L'index des pages d'explication en français, de la définition du terme au fonctionnement de la réservation.
- [Qu’est-ce que Murmell ? Plusieurs agents de code sur un même dépôt](https://murmell.com/fr/quoi/murmell): La réponse courte : ce qu’est Murmell, ce que vous voyez et ce qu’il advient du code.
- [Agent IA cloud pour coder : fonctionnement sur un dépôt distant](https://murmell.com/fr/quoi/agent-ia-cloud): Ce qu'un agent de code exécuté sur une machine distante fait concrètement, et ce qu'il lui faut pour démarrer.
- [Claude Code dans le navigateur, sans rien installer](https://murmell.com/fr/quoi/claude-code-dans-le-navigateur): Comment le CLI Claude Code tourne sur une machine distante et s'affiche dans un onglet, sans installation locale.
- [Coder à plusieurs avec des agents IA](https://murmell.com/fr/quoi/coder-a-plusieurs-avec-des-agents-ia): Les deux volets du multijoueur sur Murmell : plusieurs agents et plusieurs personnes pour les observer.
- [Coder avec l'IA dans le cloud, en pratique](https://murmell.com/fr/quoi/coder-avec-lia-dans-le-cloud): Le déroulé concret d'une session de code assistée par IA sur une machine distante, du dépôt vide au commit.
- [Figma pour les développeurs : un canvas multijoueur pour le code](https://murmell.com/fr/quoi/figma-pour-developpeurs): Ce que l’analogie avec Figma dit de vrai sur Murmell, et où elle s’arrête.
- [Glossaire de l'IA de code dans le cloud](https://murmell.com/fr/quoi/glossaire): Les termes du domaine, définis court : agent, canvas, réservation de fichier, bac à sable, contexte, jeton.
- [L’IA cloud pour développeurs : modèles, API et agents de code](https://murmell.com/fr/quoi/ia-cloud): Les trois sens de « IA cloud », et celui qui concerne quelqu'un qui veut faire écrire du code par une machine distante.
- [La machine cloud où tournent les agents](https://murmell.com/fr/quoi/machine-cloud-pour-agents-ia): Ce que contient la machine qui exécute le code des agents, et pourquoi elle ne contient rien d'autre.
- [Les agents IA de code, rangés par ce qui les sépare](https://murmell.com/fr/quoi/meilleurs-agents-ia-de-code): Le panorama des agents IA de code, rangé par l'endroit où chaque outil envoie un agent supplémentaire.
- [Plusieurs agents IA sur un même dépôt](https://murmell.com/fr/quoi/plusieurs-agents-ia-un-depot): Le mécanisme de réservation de fichiers qui laisse plusieurs agents écrire dans un seul dossier partagé.
- [Verrouillage de fichiers pour agents IA : éviter les collisions](https://murmell.com/fr/quoi/verrouillage-de-fichiers-agents-ia): Comment la réservation de fichiers au niveau serveur et les captures de sécurité permettent à plusieurs agents IA de coder ensemble.
- [Guides : faire travailler des agents IA](https://murmell.com/fr/comment): L'index des guides français, en étapes numérotées, du premier agent à la session partagée.
- [Comment utiliser Claude Code sans rien installer](https://murmell.com/fr/comment/utiliser-claude-code-sans-linstaller): La marche à suivre pour ouvrir un vrai terminal Claude Code depuis un navigateur, sans installation locale.
- [Comment coordonner Claude Code et Codex sur un même projet](https://murmell.com/fr/comment/coordonner-claude-code-et-codex): Comment répartir le travail entre Claude Code et Codex sur un canvas Murmell partagé avec réservation de fichiers en temps réel.
- [Comment lancer plusieurs agents IA sur un projet](https://murmell.com/fr/comment/lancer-plusieurs-agents-ia): La marche à suivre pour faire tourner plusieurs agents de code sur un même dossier, du projet vide à la répartition des fichiers.
- [Comment montrer une session de code en direct](https://murmell.com/fr/comment/partager-une-session-de-code): La marche à suivre pour qu'un collègue ou un client regarde une session d'agents en direct, avec un simple lien.
- [Murmell comparé, outil par outil](https://murmell.com/fr/vs): L'index des comparatifs français, rangés selon l'endroit où chaque outil envoie un agent supplémentaire.
- [Murmell face à Claude Code sur le web](https://murmell.com/fr/vs/claude-code): Le même CLI à deux endroits : une machine isolée par tâche, contre plusieurs agents sur un canvas et une seule copie de travail.
- [Murmell face à Codeg](https://murmell.com/fr/vs/codeg): Rassembler des sessions locales, contre faire tourner les agents sur un dossier cloud partagé.
- [Murmell face à Codex cloud](https://murmell.com/fr/vs/codex-cloud): Pourquoi lancer le CLI Codex sur un canvas partagé n'est pas la même chose que lui déléguer une tâche.
- [Murmell face à Conductor](https://murmell.com/fr/vs/conductor): Une application Mac avec un espace par tâche, contre un canvas cloud avec un seul dossier pour tous.
- [Murmell face à GitHub Copilot et Agent HQ](https://murmell.com/fr/vs/github-copilot): Où le travail des agents converge : à la pull request, ou dans la copie de travail.
- [Murmell face à Cursor](https://murmell.com/fr/vs/cursor): Un éditeur par personne et une machine par agent, contre un canvas et un dossier pour tout le monde.
- [Murmell face à Devin](https://murmell.com/fr/vs/devin): Le parallélisme par séparation contre le parallélisme par partage, et quand chaque forme est la bonne.
- [Murmell face à Gemini Code Assist](https://murmell.com/fr/vs/gemini-code-assist): Un agent supervisé dans votre éditeur, contre plusieurs agents non supervisés dans un dossier que vous regardez.
- [Murmell face à Google Jules](https://murmell.com/fr/vs/google-jules): Un plan que vous approuvez et une pull request que vous relisez, contre des terminaux que vous regardez dans un seul arbre.
- [Murmell face à OpenHands Agent Canvas](https://murmell.com/fr/vs/openhands): La comparaison la plus proche de la liste : un worktree par agent contre un seul arbre avec des réservations de fichiers.
- [Murmell face à Replit Agent](https://murmell.com/fr/vs/replit-agent): Fabriquer une application à partir de rien