Murmell

Murmell

Murmell is a shared cloud canvas for teams and AI coding agents, enabling Claude Code, Codex, Kimi, OpenCode, and other tools to work simultaneously in one repository with live collaboration and file-level write protection.
https://murmell.com/?ref=producthunt
Murmell

Product Information

Updated:Aug 4, 2026

What is Murmell

Murmell is a browser-based collaborative development environment designed for teams using multiple AI coding agents. It runs agents on cloud machines in a shared project directory, giving each agent its own real terminal while allowing teammates and invited viewers to observe the same workspace, terminal activity, cursors, and progress in real time. Murmell supports providers including Claude Code, Codex, Kimi, and OpenCode, which users connect through their own accounts or API keys. Project work is stored in a private GitHub repository, while the cloud workspace can be disposed of after work has been pushed.

Key Features of Murmell

Murmell is a browser-based shared cloud workspace for coordinating multiple AI coding agents and human collaborators on one repository. It runs supported command-line agents such as Claude Code, Codex, Kimi, and OpenCode in separate terminal windows on a cloud machine, while giving all participants a live shared canvas, real-time terminal visibility, and file-level write coordination. Agents claim paths before editing, helping teams avoid conflicting changes and reducing the need for separate clones and end-of-project merge work.
Shared cloud coding canvas: Hosts a project on a cloud machine and lets multiple people view the same live browser canvas, including agent windows, cursors, names, and terminal output.
Multi-agent support: Runs Claude Code, Codex, Kimi, OpenCode, and additional command-line coding tools in separate terminal windows against the same project directory.
File-path claiming and collision protection: Agents claim files or paths before writing; the workspace blocks competing holders and snapshots colliding writes so changes are not silently lost.
Built-in orchestration agent: Users can describe a task to Murmell’s own agent, which can open terminals and distribute repository work among multiple coding agents.
Persistent cloud execution: Agents continue running on Murmell’s machines even after a user closes their laptop, with usage not metered by hours or number of open windows.
Private GitHub-backed projects: Each project is associated with a private GitHub repository, allowing work to persist even though the active cloud workspace itself is disposable.

Use Cases of Murmell

Parallel feature development: A software team can assign separate agents to UI components, API integrations, tests, and styling while they work in the same repository with reduced file conflicts.
Live AI pair programming: Developers can share a canvas link with teammates or stakeholders so they can watch agents implement, debug, and explain changes in real time.
Overnight development and long-running tasks: Teams can leave agents running cloud-based builds, refactors, test fixes, or research tasks without keeping local laptops open.
Startup prototyping: Small product teams can rapidly divide prototype work among agents—for example, one agent building a game loop, another creating the interface, and another wiring the preview.
Codebase modernization: Engineering organizations can coordinate agents to update dependencies, migrate framework components, improve test coverage, and refactor modules in a shared workspace.
Remote technical collaboration: Distributed teams, agencies, or coding mentors can use a single live workspace to review implementation progress and coordinate AI-assisted development without exchanging local setup instructions.

Pros

Enables several AI agents and people to work on one repository without relying on separate clones and later merges.
Uses file-level claims and collision snapshots to reduce accidental overwrites during parallel work.
Cloud execution allows work to continue independently of a developer’s laptop.
Supports multiple popular coding-agent tools while users retain their own provider accounts and API keys.

Cons

It is a paid, cloud-hosted product, with plans starting at $39 per month.
Users must bring and pay for their own AI-agent subscriptions or API keys; model-token costs are not included.
Self-hosting is not available, which may not suit organizations with strict infrastructure or data-residency requirements.
The path-claiming workflow can introduce waiting when multiple agents need to modify the same files.

How to Use Murmell

Choose a plan and create an account: Open Murmell and register for Solo, Pro, or Builder. Plans include a seven-day free trial. Choose Pro or Builder if you need to share a canvas with others.
Create a project canvas: Create a new project in Murmell. Murmell provisions an isolated cloud machine and a shared project directory for that canvas.
Connect your coding-agent account or API key: Sign in to the AI coding tools you already use, such as Claude Code, Codex, Kimi, or OpenCode. Murmell runs these command-line tools on its cloud machine and does not resell model tokens or store your key.
Open agent terminal windows: Launch one or more supported agents in their own terminal windows on the canvas. The number of simultaneous windows depends on your plan: Solo supports two, Pro supports five, and Builder supports unlimited agent windows.
Assign work to agents: Give each agent a specific task or area of the repository. You can also tell Murmell's built-in agent what you want built; it can open terminals and distribute portions of the repository among agents.
Let agents work in the shared directory: All agents operate on the same project directory rather than separate clones. Watch their terminal output and file activity live in the browser.
Use file claims to avoid conflicts: Before an agent writes to a path, Murmell requires it to claim that path. Only one agent can hold a file path at a time; other agents wait until the claim is released. If a write collides, Murmell snapshots the existing write so work is not lost.
Invite collaborators or viewers: Send the canvas link to teammates or stakeholders. People with the link can watch the live canvas without an account while it is running, including cursors, participant names, terminal output, and agent activity.
Collaborate in real time: Collaborators can join the same canvas simultaneously. Each person can drive their own agents while everyone remains synchronized without refreshing or replaying activity.
Keep agents running in the cloud: Leave long-running agent tasks active even after closing your laptop. Murmell does not meter usage hours; the agents continue on the cloud machine.
Retrieve the finished work from GitHub: Murmell creates a private GitHub repository for the project and pushes work before its disposable workspace is torn down. Use that repository as the durable source of your completed code.

Murmell FAQs

Murmell is a browser-based shared canvas where multiple AI coding agents, including Claude Code, Codex, Kimi, and OpenCode, run on a cloud machine and work from one shared project directory. Each agent has its own real terminal window, and people with the link can see the canvas in real time.

Latest AI Tools Similar to Murmell

invoices.dev
invoices.dev
invoices.dev is an automated invoicing platform that generates invoices directly from developers' Git commits, with integration capabilities for GitHub, Slack, Linear, and Google services.
Monyble
Monyble
Monyble is a no-code AI platform that enables users to launch AI tools and projects within 60 seconds without requiring technical expertise.
Devozy.ai
Devozy.ai
Devozy.ai is an AI-powered developer self-service platform that combines Agile project management, DevSecOps, multi-cloud infrastructure management, and IT service management into a unified solution for accelerating software delivery.
Mediatr
Mediatr
MediatR is a popular open-source .NET library that implements the Mediator pattern to provide simple and flexible request/response handling, command processing, and event notifications while promoting loose coupling between application components.