If you use Claude Code and Codex at the same time, you have been here: Claude finishes a round of front-end work, and you want Codex to pick it up. So you manually summarize what Claude changed, what you discussed, and what the preview looks like, then paste all of it into Codex.
Add a friend running their own Agent, and it gets worse. You are forever sending files back and forth, pasting progress updates, and recounting what your Agent just did. You become a human ferry between Agents.
This is exactly what Tutti · VM is built to fix: letting multiple people and multiple Agents collaborate in real time, in one shared space, with no manual context handoff.
The Core Idea: A Shared Work State
Tutti · VM doesn’t have Agents send messages to each other. Instead, it puts every Agent’s work state into the same cloud Room.
Work state comes in three parts:
- What is being said: what each Agent is discussing and with whom, plus the full history. Every instruction, reply, follow-up, and clarification, visible to everyone and every Agent in the Room.
- What is being done: everything happening in an Agent’s work right now, which files it is changing and how, how far the task has gotten, whether anything errored, what the preview looks like. This updates live, so people and Agents in the Room always see the latest.
- What is done: an Agent’s finished output, code, images, documents, design files. These artifacts stay in the Room in their final state and become context for the work that follows.
Because Agent commands are issued through the Room, this work state lives in the Room by default, where everyone and every Agent can see it.
That removes the old “finish → summarize → hand off → re-understand” loop. Agents collaborate directly on one shared work state, sense what the others are doing in real time, and work out for themselves what can run in parallel and what has to wait.
One Person, Multiple Agents
Open Claude Code and Codex in the same Room. When Claude finishes a version (or is still mid-task), switch to Codex’s chat, type @, and pick Claude’s conversation. Codex gets Claude’s history, file changes, and preview state directly, and carries on.
A concrete example: you have Claude Code write the front-end components while Codex writes the back-end API, both running in parallel in the same Room. Once Claude finishes a component, Codex already sees what the front-end interface looks like through the shared work state, and wires up to it, with no need for you to tell Codex “here is what Claude’s interface looks like.”
Several People, Each with Their Own Agents
You create a Room and invite a friend in. They join with their own Agent, and both of your Agents now run in the same space.
You can each see what the other is doing. Open the Agent Board, and every person’s Agent conversations, execution, and output are laid out at a glance, sorted into in progress / completed / failed / stopped. See a task you want to take over? Use card forwarding to hand it to your Agent, or @ that conversation in your chat to continue it.
For the Agents, the old model was: Agent A finishes, summarizes, hands the result to a person, who passes it to Agent B, losing context detail along the way, so Agent B has to re-understand the project. Now A and B collaborate on one shared work state and decide for themselves what to parallelize, what to wait on, and how to avoid conflicts.
A concrete example: you and a friend build a full-stack project together. Your Claude Code owns the front-end, their Codex owns the back-end. You each work on your own computer, but both Agents’ work states live in the same Room. When your Claude finishes the login-page component, your friend’s Codex sees the component’s interface definition right away and wires up the back-end auth logic, with no need to message each other “here is what my interface looks like.”
Editing the Same Thing at Once: Something Other Products Can’t Do
This is Tutti · VM’s most distinctive collaboration capability, and the feature we are most excited about.
The scenario: you and a friend edit the same front-end page at the same time. You work on the Header component, they work on the Footer, both of you in the same file.
This used to be nearly impossible. Whether you merge Git branches or use a cloud devbox, the biggest pain of several people editing one file is conflict: you changed line 30, they changed line 30, and merging means resolving it by hand. When both people edit often, conflicts pile up until collaboration just isn’t workable.
In Tutti · VM, this is solved.
We use sophisticated collaborative-editing technology, similar to Google Docs’ real-time collaboration, but applied to an Agent’s working environment rather than a document. Specifically:
- Real-time awareness: the moment your Agent changes a line, your friend’s Agent knows. Not “transferred after the fact”, but real-time, millisecond-level awareness.
- Automatic conflict avoidance: when two Agents try to edit the same region at once, the system coordinates automatically, the way two cursors in Google Docs never fight each other.
- Live preview: you both watch the preview change as it happens. You edit the Header and it updates instantly; they edit the Footer and it updates instantly. Each of you sees the other’s changes appear in real time, with no “commit” to wait on.
Why can’t other products do this?
- Cloud devboxes (e.g. Gitpod, Codespaces): they solve “one cloud environment per person”, not “several people editing the same file.” Multi-person work still runs on Git branches and merges, so conflicts remain.
- Local-only Agents (e.g. Cursor, Windsurf): single-machine tools, with no mechanism for a shared multi-Agent environment at all.
- Agent orchestration platforms (e.g. Devin, Factory): a “here’s an Agent” model. You can’t bring your own Agent in, let alone have several Agents edit the same thing at once.
- API-mode Agent platforms: Agents pass messages over an API and don’t share a runtime, so real-time awareness and conflict avoidance are out of reach.
Tutti · VM can do it because the architecture puts “work state” in a shared cloud Room from the start, and every Agent works off the same real-time state. This isn’t a feature bolted on later; it is a natural result of the underlying architecture.
And this is more than just “skipping merge conflicts.” It changes the grain of collaboration, from “you do a version, then I do a version” to “we work on it at the same time.” From serial to parallel. From handoff to co-creation.
Collaboration and Connection Are Primitives
In Tutti · VM, collaboration and connection aren’t a feature that had collaboration added to it. They are the most fundamental primitives. That means:
- Everything in a Room supports several people operating it at once, by default.
- Every app in the App Center has collaboration built in, so multiple people can work in the same app at the same time.
- Every Agent naturally senses the other Agents in the Room.
This isn’t a capability special-cased into one app; it emerges naturally from the underlying architecture.
Why This Isn’t “Relaying Messages”
The traditional way Agents collaborate is communication: Agent A finishes, summarizes the result, sends it to Agent B, and B re-understands it before starting. Context is inevitably lost in the transfer, the decisions A made, the things it found while debugging, the half-finished pieces along the way, all of it tends to get dropped in the summary.
Tutti · VM’s way is sharing: every Agent shares one work state, so whoever needs a piece of information gets the complete, undamaged version the instant they need it. It is like playing co-op online with a friend, you don’t stop every ten minutes to say “here is what I just did”, they glance over and already know.
Collaboration that is real-time, continuous, and needs no translation. That is Tutti · VM’s answer to multi-Agent collaboration.
