Every AI coding agent shipped so far is built for one person in one session. The work a team actually does together, in the same place, at the same time, has no home. Coshell is that home: a shared live session your whole team prompts at once.
What is multiplayer AI coding?
Multiplayer AI coding is when several engineers prompt one shared, live AI agent working in a single cloud workspace: the same files, the same terminal, the same browser preview, open to everyone in the session at once. Instead of each developer running their own agent in their own copy of the code and merging the results later, the whole team works with one agent, in one place, in real time. Coshell is the product built around it.
| Single-player AI coding | Multiplayer AI coding | |
|---|---|---|
| Who is in the session | One developer, one private session | The whole team, one shared live session |
| The agent | Each person runs their own | One agent everyone prompts together |
| The codebase | Re-loaded into every person's session | Read once, kept warm for the team |
| Overlapping edits | Diverges into copies, merged by hand later | Caught and steered before a clobber |
| Visibility | Invisible until it lands as a diff | Everyone sees the work as it happens |
| Closest analogy | Each person editing their own copy in git | A whole team in one Google Doc |
Claude Code, Codex, Cursor: each is a private channel between one developer and one model. That was the right shape for the first wave. One person, one context window, one transcript. It made individuals dramatically faster, and it is why these tools spread.
But software is not written alone. The moment a second person is involved, the single-player shape starts to cost you. Each developer reloads the same codebase into their own session, so the team pays to ingest the same context again and again. Work happens inside isolated transcripts nobody else can see until it lands. There is no shared way for a team to operate the agent, only a stack of separate conversations that have to be reconciled by hand afterward.
The industry's answer has been to run more agents: a swarm of bots, each in its own box, opening pull requests you review later. That is more parallelism, not more collaboration. It is still single-player, just with more players who cannot see each other. The seam between the people is exactly where nothing has been built.
See how it compares to Claude Code.
A share link is a recording of work that already happened.A shared session is the work, happening, with everyone in it.
Multiplayer means many people prompting one live agent on one source of truth. Not many agents. Not many copies. One session, shared, closer to a Figma file or a Google Doc than to git. Everyone sees the same files, the same terminal, the same browser, the same agent, live. You stop merging each other's work because there was never a second copy to merge.
A shared session removes the worst class of collision: with no diverging copy, there is nothing to lose and nothing to merge. But two agents can still reach for the same lines of the same file, and the engine underneath is last-write-wins. Overlap catches that: the second edit is held before it lands, and a coordinator steers that agent to proceed if the changes are compatible, or to take other lines, wait, or let the first land first. This is the part isolated, single-player agents cannot do, because they never share a session to coordinate inside of.
The validated complaint about AI agents is that they burn most of their tokens re-reading context. In a single-player tool that cost is unavoidable and it is paid per person: every developer's session ingests the repository from cold.
A shared session inverts it. The team's session loads the codebase once and keeps it warm. Cached reads cost a fraction of fresh input, so the more context-heavy the work, the more a single warm cache compounds across the team. The same property that makes the session collaborative, one context everyone shares, is the property that makes it cheaper. Nobody else frames token efficiency as a team benefit because nobody else has a team session to cache.
It is a fair question, and the answer is structural, not a matter of time. A coordination layer for a team is only valuable if it is neutral across the things a team actually uses: many models, many providers, the repos and the infrastructure you already have. A model owner is disincentivized from building exactly that. Their product is the model, and their incentive is to keep you in one model's session, not to sit above all of them.
Anthropic shipping Agent Teams, and the steady drift toward "Claude Code for teams," is the tell. The demand for humans collaborating around an agent is real and growing. But the version a model vendor ships will be collaboration inside their model, on their terms. The layer that matters, the one between the people, has to be neutral to be useful: 70+ models on your own keys, pushing to your own git, and on the enterprise tier runs on your own infrastructure so your code never leaves it.
That neutrality is not a feature we bolted on. It is the reason an independent layer can exist at all. Coshell is a fork of OpenCode, the open agent engine with 174k stars on GitHub. We did not rebuild the agent. We built the one thing a single-player tool can never be: the shared session the team works in together.
None of this is a roadmap. It is the product, today: join from a browser or attach from the CLI, keep a session private or open it to the drive, and push to your own repositories. Pair with the agent as a team the way you already pair with each other.
We did not rebuild the agent. We built the one thing a single-player tool can never be: the shared session the whole team works in together.
Several people in one live session at the same time, prompting one coding agent and watching its work as it happens, on a shared filesystem, terminal, and browser. It is the opposite of running many separate agents in many separate boxes. One agent, one session, many people. Closer to a Google Doc than to git.
A share link is a read-only recording of work that already happened. A shared session is the work happening now: presence, follow-along, one prompt stream, and the same running environment for everyone in it. Not a transcript you send afterward.
No. Parallel agents are more single-player sessions running at once, each isolated, each reviewed after the fact. That is more parallelism, not collaboration. Multiplayer is many people inside one shared session, coordinated live, with overlapping edits caught and steered before they clobber.
You can, one person at a time. They are excellent single-player tools, and Coshell is built on the same open engine. What they do not have is a shared session: a team still ends up with one transcript per person, the same codebase re-ingested per person, and reconciliation done by hand. Coshell adds the layer between the people. See how it compares to Claude Code.
Open a drive in the browser, or attach from the CLI. Your whole team works in one shared live session, on the same codebase.