What a link has to carry to share a live coding session
Sharing a live coding session means sending one link that carries three things: which canvas it opens, whether the person may edit or only watch, and a name to put on their cursor. The running application has to be served through that same session rather than on a public address, or the sharing feature becomes a way to publish somebody’s development server.
A screen share shows a person’s screen. That is the wrong shape for an agent that is going to run for twenty minutes, because the interesting thing is not what somebody is looking at, it is what the machine is doing, and the person may well be asleep. What we wanted instead was a link: you send it, somebody opens it, and they are in the room.
Three things, and none of them is a video stream
Nothing is being streamed. The session is not on anybody’s laptop to begin with, so joining is not a matter of copying pixels from one machine to another. The link has to carry three facts and that is all: which canvas it opens, what the person opening it is allowed to do, and what to call them once they are there.
The second one is the one people underestimate. A canvas handed out read only and a canvas handed out to work on are the same picture and a different product, and the difference has to live in the token rather than in the interface. An interface that hides the input box from a viewer is a suggestion; a link that never carried the right to write is a rule.
The third turns a shared screen into a room. Every person on the canvas is a coloured dot and a name, and the state next to it says whether they are watching or working. That is also the product’s one colour rule doing its job: a saturated colour on this canvas means an agent or a person, never decoration.
The part that is easy to get dangerously wrong
Agents build an application, and the point of watching them is seeing it run. So a canvas has a Live Preview: a window showing whatever the development server inside the sandbox is serving, refreshed as the code changes.
The tempting implementation is a hostname per canvas. Give the sandbox a public address, point a wildcard certificate at it, done in an afternoon. We refused it, and the reasoning is the same one that governs the recording behind our own sign in: a URL that anybody can reach is a gate you can walk around, and it would mean the sharing feature quietly published somebody’s unfinished application to the internet on a guessable address.
The preview is therefore served through the session that is already authenticated. The browser asks the control plane, on a path scoped to the canvas, carrying a grant that lasts minutes rather than forever. The control plane forwards the request across the same link the terminals use, and the fetch to localhost happens inside the sandbox, where it belongs. There is no preview hostname, because there is nothing that could be typed into a browser by somebody who was never given the canvas.
What it costs
Being honest about the trade: proxying a development server through a session is more work than pointing DNS at it, and it constrains what the preview can do. Every response passes through a bound on its size, and something a browser would happily stream from a public host has to fit through a channel that was built for terminal output.
We think that is the right way round. A preview is for watching an application take shape in front of the people who are building it, and for that it needs to be exactly as reachable as the canvas and no more. Anything wider is a publishing feature nobody asked for, shipped by accident.
The thing sharing actually changes
Once a session is a link rather than a machine, the question of who can look at it stops being a scheduling problem. There is no call to set up and no screen to hand over, and the agents do not stop when the person who started them closes the tab. Keeping that browser attached honestly is its own piece of work, and the reason a second person opening the same canvas does not slow the first one down.
Straight answers
How do you share a Claude Code session with your team?
On Murmell, by sending the canvas link. Whoever opens it is in the same canvas, sees the same terminals live, and appears as a named cursor. There is nothing to install and no screen to share, because the session was never running on anybody’s laptop.
Can somebody watch without being able to type?
Yes. The link carries the role, so a canvas can be handed out as read only, and the people on it are drawn with what they are doing: viewing, or editing.
Is the app the agents are building reachable by anybody with the URL?
No. The development server listens on localhost inside the sandbox and is proxied through the authenticated canvas session, on a short lived grant. There is no public preview hostname to guess.