Work live with people and agents

Shyne treats the document as a live graph that several writers can change at once. A person dragging a frame and an agent recoloring a heading are two edits on the same project. Both persist. The canvas does not reload.

That is a small sentence with a lot of history behind it. Most “AI in the editor” products still have a hidden copy. The model writes somewhere else. A merge step brings the result back, or replaces the page entirely. The human waits. The undo stack is a suggestion. A collaborator who typed during the wait loses a paragraph. We did not want that product.

The structured Yjs graph is the document. Humans and AI agents edit that same graph live as peers. The editor projects the graph to real DOM for direct manipulation. Sync happens over a Durable Object. Agent operations mutate the same structured nodes and broadcast to every open editor.

Presence you can see

When someone else is in the project, you see them. When the agent is working, you see that too. The point is not a chat transcript that describes the work. The point is watching the work itself.

You can interrupt. You can select a frame and ask for a change. You can keep typing while the teammate finishes a different region. Those are ordinary concurrent edits, not a special “AI mode.”

Presence is not a toy cursor. It is how you know whether to wait, join, or redirect. If two people grab the same heading, you see the collision as it happens, the same way you would see it in any serious multiplayer editor. The agent is not exempt. If it is rewriting the title you just finished, you stop it. You do not discover the overwrite in a notification tomorrow.

Desktop and hosted MCP use the project’s live awareness channel. presence_get lists collaborators who are present now, with their current canvas selection and cursor when available. An empty result means nobody else is currently present; it is not a directory of everyone who can access the project.

Why the document stays whole

Shyne does not send the agent a blob of HTML and hope it comes back intact. The agent reads structured nodes and writes structured nodes. HTML is for import, export, and the rare moment you replace a frame on purpose.

That is why undo still works after the teammate has been through the canvas, and why two people can share a project without taking turns. One user gesture is one transaction and one undo step. After a completed gesture, capturing stops so the next action cannot merge into the last one. The agent is held to the same idea: a logical mutation should arrive as one write you can undo, not as bake-plus-reparent-plus-demote scattered across three surprises.

If a recent human edit disappeared, the usual cause is a stale read. The agent wrote from a picture of the frame that no longer matched the canvas. Undo the change. Ask it to re-read the frame just before writing, and to keep everything outside the requested change. That is not a polite request. It is the working loop: orient, read, change, look, report.

One seat per person

Each person brings their own agent and their own identity. Project roles still decide who can view, edit, or manage. The teammate is powerful, but it is not a second owner of the project.

A viewer’s writes are dropped. A trashed project freezes to read-only for everyone. People with manage access handle access requests. Editors make the work. The in-product approval flow already exists for people who should not have been guessing at permissions in a spreadsheet.

The agent authenticates as the user who invoked it. On the web that is a user token or a session. On the desktop it is the signed-in seat. Organization API keys are for servers calling REST, not for a person pretending to be a shared bot. There is no god-mode credential in the product for everyday use.

This is the opposite of “the company has one AI user.” If three consultants are in a project, there are three seats and, if they want them, three teammates. They still share one graph. They do not share one pair of hands.

What live actually feels like

A good session looks ordinary. You are talking in another window. The deck is open. You ask for a tighter title on frame four. The heading changes. Your colleague, already on frame four, shortens the subtitle because it now collides. You both sit in the same bound. The agent is not a modal. The colleague is not a lock.

A bad session looks ordinary too, which is why the rules matter. If the agent could replace the whole frame from HTML on every turn, your colleague’s subtitle would be gone. If undo were reset by “AI applied a change,” you would stop inviting people into the project. If presence were hidden, you would work in fear of collision instead of in view of it.

We would rather show the mess than hide it behind a spinner.

Tasks and projects are not the same conversation

A task is a durable agent conversation in the workspace. It may be filed in one project. Opening a project does not create a task, and it does not move one. That split keeps the document from becoming a chat log, and it keeps the chat from becoming a second document.

You can talk for an hour and only then file the useful task against the launch project. You can open the launch project and say nothing, because the work is already on the canvas. Collaborators who never open your task still see the shared frames; your task remains private to you by default. The project is the collaboration surface, while the task is your durable conversation with your agent.

The current canvas selection still rides with a prompt when you are in the editor. That is context, not a hidden “current document” stored in the graph. The graph does not have a mutable shared pointer named main. Addressing is explicit.

Sharing without losing the room

A project is the collaboration boundary. You share the project, not a mysterious file on a laptop. Roles travel with it. Files travel with it. Canvases travel with it. A desktop working copy is a replica of project files, not a second identity. If you send someone a local folder and call it the project, you have left Shyne’s model.

Link-only access is narrower than people expect. A linked project can be visible in the app and still absent from a global projects_list. The agent has to address that project directly so access can be rechecked. This is inconvenient in the first hour and correct in the first audit.

When to work alone, when to invite

Work alone when you are still finding the shape. Invite someone when the sequence has an order you would defend. Invite the teammate earlier than you think, because a first pass you can delete is cheaper than a blank frame you are precious about. Invite a viewer when the question is “does this read,” not “please move this 4px.”

The live document makes those invitations cheap. You are not exporting a preview PDF so a stakeholder can comment in email. They can be in the project at the level you chose. If they should not edit, they do not get edit. If they should not manage publishing, they do not get that capability.

Conflicts, stale reads, and manners

Two writers on the same node will produce a last-applied result that may not be the one you liked. That is multiplayer, not a bug. Talk, undo, or take turns on that node. Do not ask the agent to “just fix everything” while a human is mid-gesture. The click-versus-drag threshold exists so a first pointer move does not write. Give people the same courtesy you give the pointer.

If you are about to ask for a wide rewrite, say which frames are in bounds. A teammate with a stale whole-canvas read is the fastest way to lose a careful human hour.

If you are about to import HTML over a frame, know that you are replacing, not merging. That operation is explicit because it is destructive in the ordinary sense: the previous node tree of that frame is gone.

The point of doing this the hard way

It is easier to generate a file. It is harder to keep a graph consistent, undoable, and shared. We took the harder path because the file is not where the week is spent. The week is spent in the live document, with other people, with an agent that should behave like a colleague who can type very fast and still be interrupted.

Work live. Watch the hands. Keep the undo. Share the project, not a copy. That is the whole collaboration model, and it is why the teammate can sit in the same room as you without kicking you out of it.