Someone asked Claude Code for multiplayer. We’d already built it.

Someone filed an issue on the Claude Code repo. The summary:

There is currently no way for two different user accounts to share and collaborate on a single Claude Code session in real time (think Google Docs / VS Code Live Share, but for a Claude Code chat).

They were precise about why the existing options don’t count. “Share links from claude.ai are read-only views, not collaborative.” “Teammates and peer sessions all belong to the same account — different devices/processes, not different humans.” Remote Control moves your own session between your own machines. And so “the only workarounds are screen sharing (one person types) or tmux session sharing.”

We know, because we built Bottari after losing a year of afternoons to exactly those workarounds. So instead of writing a launch post, let’s just walk their list.

“Pair programming with a colleague where both can prompt the same agent.”

Your agent is mid-task on checkout retries. Your colleague opens the session you already have running — not a copy, not a transcript, the live one — and types into the same thread. Each message carries who sent it, so the agent knows it’s talking to two people instead of one person changing their mind. You say “split this into two PRs,” they say “nullable column first,” and the agent takes both.

“Mentoring / onboarding: a senior dev watches a junior’s session live and can intervene.”

A junior is stuck on a stack trace at 4pm. Instead of pasting logs into Slack and writing three paragraphs of background, they @ their lead inside the session. The lead lands in the running context, reads the last four turns, and says “line 12, the object never gets passed.” No setup, no recap, no screen share where only one person can type.

The sidebar helps before that point too. Every active session in your space carries a dot: working when the agent is running, attention when it’s stopped waiting on a human, idle otherwise. You can see which of your teammates’ sessions is stuck without asking anyone.

“Live code review where reviewer and author both interact with Claude in the same context.”

Reviewing a frozen diff means reconstructing intent. In Bottari the reviewer opens the run that produced the change and sees the tool output and diffs that got it there — then asks the agent directly why it chose that approach. The agent answers from its own reasoning, not from your reconstruction of it.

And the artifact under review is one artifact. Documents are edited concurrently, two cursors at once, the agent typing alongside you. There is no spec_final_FINAL(2).md.

“Async handoff where a teammate picks up exactly where you left off (richer than a shared transcript).”

You take a half-day. Instead of writing a handoff doc nobody can act on, you reassign the session. It continues on your lead’s machine, under their own Claude login, with the whole reasoning trail intact — so they can ask “why did we drop the queue approach?” and get the real answer instead of your summary of it.

This also works while you’re asleep. If your agent stops on an approval at 3am, a teammate can open the session and clear it. Your machine answers even with the window closed.

“Permission scopes: view / suggest / write”

This was the first implementation shape they proposed, and it’s the one we care most about. A Bottari session is private, or shared at view, comment, edit, or full.

The default is comment — and a comment never reaches the model. It lands in the session for the owner to act on, which means by default a teammate can read along and weigh in without being able to make your agent do anything. Edit is granted per person, deliberately, because an edit teammate’s turn opens on your machine, against your files and permissions. That should be a decision, not an accident.

It’s also how a side question stops being destructive. Someone drops a question into the middle of a 40-minute run? It goes in a thread branched off the specific reply it’s about, pulls in whoever it needs, and runs there — while the main task keeps going, untouched.

What we don’t have yet

Their third shape was “read-write share links with expiry, similar to Figma/Notion.” Not yet. Links open in the Bottari app today and entering a session needs a team invite. Expiring links are next.

The actual point

The thing that stuck with us from that issue wasn’t the feature list. It was this:

Claude Code is increasingly used inside teams, but the paradigm is still “single user + agentic delegation.” For software work that is fundamentally collaborative, this is a gap.

That’s the whole thesis. Claude made each of us faster and left the team exactly as slow as before, because the handoffs, the recaps, and the “which file is your agent touching” questions are all still manual. Bottari isn’t a different AI. It’s your Claude, with your team in the room.