Most "collaboration" in design tools still happens in turns. One person edits, saves, and tells everyone else to refresh. The next person opens the file, makes changes, and the cycle repeats. It works, but it is not really working together — it is taking turns in a shared folder.
Builder Studio now runs the canvas as a realtime multiplayer space. When your teammates open the same canvas, you see them: their cursors moving, and the nodes they are dragging or resizing, as it happens. The work you do to design and run AI workflows is the same work — you can just do it side by side now, in real time.
What multiplayer means on the canvas
Multiplayer is more than a shared link. On the Builder Studio canvas it means two things are live at once:
- Presence — you can see who else is in the canvas and where their attention is.
- In-flight gestures — when someone drags or resizes a node, you see the move while it happens, not after it lands.
All of this runs on the canvas where you already build: prompt nodes, generation nodes, connections, and the workflows that tie them together. Multiplayer does not move your process into a separate "comment mode." It puts other people directly into the build.
See everyone on the canvas, live
The first thing you notice in a shared canvas is that you are not alone in it.
Live cursors and presence
Every collaborator gets a labeled cursor that moves in real time. You can tell at a glance who is in the canvas, which region they are working in, and whether two people are about to reach for the same node. Presence is the cheap, constant signal that turns a static document into a shared room.
Cursors stream over a dedicated low-latency channel built for exactly this kind of high-frequency, lightweight traffic, so movement stays smooth even when several people are active at once.
Ghost drag and resize
Presence tells you where someone is. Ghost gestures tell you what they are doing.
When a teammate drags a node or resizes it, you see a semi-transparent preview of the change as they make it — before they release. Instead of nodes silently teleporting into new positions on your screen, you watch the move happen and understand the intent behind it. It is the difference between "the layout changed" and "Sam is lining these two generation nodes up."
This matters most in the messy middle of building, when two people are arranging the same part of a workflow. Seeing in-flight moves prevents the small collisions — two people grabbing the same node, or reorganizing the same cluster at cross purposes — that make shared editing feel fragile.
How it stays fast and clean
Realtime is only useful if it is smooth, so multiplayer is built to stay light and stay out of your way.
- A purpose-built realtime channel. Cursors and gestures travel over a dedicated low-latency connection per canvas, separate from your durable canvas data, so high-frequency movement never competes with saving your work.
- A tight wire budget. In-flight geometry — the position and size of a node mid-drag — is streamed under a small per-update byte budget. If a peer's stream falls behind, the preview degrades gracefully instead of stuttering the canvas.
- Local engagement wins. The node you are actively dragging or resizing never gets a competing ghost from someone else. Your own gesture always takes priority on your screen, so realtime previews add information without ever fighting your input.
The result is multiplayer that fits the canvas instead of bolting a second system onto it: you get the awareness of working together without paying for it in lag.
Why this matters for AI workflows
AI workflows are a team sport more often than they look. One person knows the prompt, another owns the brand constraints, a third is wiring up the generation and output nodes. When building is turn-based, that knowledge gets serialized through saves and screenshots.
Realtime presence collapses that loop. The prompt engineer can refine a node while the designer arranges the generation nodes and a reviewer watches the layout take shape — all on the same canvas, in the same minute. The workflow you are building stays the single source of truth, and the conversation about it happens on top of the real thing instead of in a chat thread next to it.
It also pairs naturally with the rest of Builder Studio. The same canvas you now build on together can be triggered by an agent over MCP, so a workflow your team designed live can be run programmatically later. Building is collaborative; running is automatable.
Start collaborating
If you already have a workspace, multiplayer is on. To work together:
- Open a workspace canvas and invite your teammates to the workspace.
- Have everyone open the same canvas — you will see each other's cursors appear.
- Build as you normally would. Move nodes, wire connections, and arrange your workflow; everyone sees the gestures as they happen.
Multiplayer changes the default from "send me the file when you're done" to "let's build it together right now." For teams designing AI workflows, that is the difference between a tool you take turns with and a space you actually share.
If you want to go further, connect the workspace to your AI agent over MCP and let it run the workflows you built together — see connecting Builder Studio workflows to your agent. And if you are still deciding whether to build workflows at all, start with the case for AI workflows.
Frequently Asked Questions
Do collaborators need their own Builder Studio account?
Yes. Multiplayer runs at the workspace level, so each collaborator signs in with their own account and joins through a shared workspace. Presence and what they can change follow their workspace role.
What can other people see while I work?
Your labeled cursor and your in-flight gestures. When you drag or resize a node, collaborators see a ghost preview of the change as it happens, not just the final position.
Does seeing someone else's drag interfere with mine?
No. The node you are actively manipulating never shows a competing remote ghost — local engagement wins — so your own drag or resize always stays smooth.