Live collaboration

Scellis is local-first: your device is the source of truth, and nothing about composing or running a workflow requires a server. Collaboration arrives on top of that core, not instead of it — Figma-style multiplayer on the workflow canvas, live runs a whole team can watch, comment threads pinned to the graph itself. Two properties hold throughout, and this page is really about them. Collaboration is strictly additive, so working alone never gets slower or more fragile. And what you share is a draft; what you cite is a commit.

Presence, down to the layer#

Open a shared session and you see the others at work: live cursors moving across the canvas, the selections they hold, the viewport each person is looking through. Presence is deliberately ephemeral — cursors and selections are never persisted and never hashed, so watching someone work leaves no trace in the artifact. It also does not stop at the top-level graph.

A model is itself a graph inside a node, so a model node on the canvas shows an aggregated badge — “3 editing inside” — and stepping into Model View resolves that badge into per-layer cursors. You can tell not just who is in the document, but who is inside which model, at which layer. Brush and hover highlights are per-peer and momentary by design; they belong to the session, not to the saved graph.

Every edit is validated, then sequenced#

A workflow is not a drawing — it is a typed, executable graph, and an executable graph needs validity, not merely convergence. That is why Scellis uses a server-authoritative-with-rebase model rather than a document CRDT: a CRDT guarantees that everyone ends up with the same bytes, but not that those bytes form a runnable program. So every edit in a live session is validated server-side before it is sequenced and broadcast: the target still exists, the new wire creates no cycle, the types check. Only then does the edit enter the shared order.

Your own client never waits for that round-trip. It applies your edit optimistically and rebases if the sequenced history disagrees, so the canvas stays immediate under your hands while the server remains the single arbiter of what the shared document actually is.

Undo respects authorship#

In a live session, Cmd+Z inverts your last edit — never a peer's. Undo is per-principal, so nobody's undo reaches across the table, and a collaborator can never quietly roll back work you did not make.

Shared runs: the run itself is multiplayer#

Editing together is half the story. When a collaborator starts a run, the run broadcasts live: its lifecycle, the loss and accuracy curves filling in point by point, output deltas as they land. Everyone in the session watches the computation happen — “Google Docs, for the GPU” — not merely the edits around it. The same live telemetry powers a training run and a distributed sweep alike.

Run control follows the Grant role. Only editors may start, pause, or cancel a shared run; viewers and commenters watch with the controls disabled and the reason stated. And a frozen curve never reads as live: the runner emits a heartbeat, and when it detaches, the stream is marked accordingly rather than letting a stalled chart impersonate progress.

Late joiners get the whole picture. Opening a session link hands a fresh participant a snapshot of the document, a replay of the edits, and current presence — and if a run is live, the metric stream from t = 0, so a newcomer sees the entire loss curve, not just the tail that arrived after them. Pooling that run across devices is a separate step, covered in distributed compute.

Notes, comments, and mentions#

Discussion lives where the work lives. A Note is markdown, anchored logically to a node, an edge, a region of the canvas, or the document as a whole — never to pixel coordinates. Comment threads carry replies and a resolved flag, and they appear for your collaborators live, as they are written. You can @mention anyone who holds a Grant on the document; a mention mints a notification that reaches them whether or not they are online.

Anchors are resilient rather than brittle. If the node a note points at is deleted, the note does not vanish with it — it becomes a detached pin with a guided re-attach flow. Prose is never lost to an edit. And note bodies stay out of the content hash: annotating a workflow does not change its identity, so a heavily discussed artifact hashes the same as an undiscussed one, and its reproducibility is untouched by the conversation around it.

Grants: named people, explicit roles#

Sharing happens through a Grant: you invite a specific person as a viewer, a commenter, or an editor, optionally with an expiry. A Grant is the per-person capability that governs a live session; how it fits the wider sharing graph — visibility lattices, share links, workspaces — is the subject of workspaces and repositories.

Revocation is instant going forward — from that moment, the next edit, the next sync, the next run event stop flowing to the revoked device. The honest limit stands right beside it: bytes a device has already synced cannot be recalled. Revocation controls the future, not the past, and Scellis does not pretend otherwise.

Additive by construction: never blocked, never lost#

The rule that keeps all of this honest: collaboration is strictly additive — a decorator over the offline-first core, never a dependency of it. For a solo editor, a server outage is a true no-op — you compose, run, and commit at full capability, because none of those paths ever depended on a coordinator. For a multi-party session, losing the coordinator suspends ordering gracefully: every participant keeps full local durability, keeps editing, and rebases on reconnect. Never a spinner between you and your own document; never lost work.

Going offline follows the same discipline. Edits made offline queue locally and reconcile on reconnect. Easy conflicts auto-resolve, with attribution, so it stays visible whose change landed where. Hard structural divergence escalates to an explicit three-way merge flow — never a silent last-write-wins. And an edit whose target vanished while you were away lands in an orphaned-edits tray with guided re-wiring, instead of being silently dropped.

Draft versus commit#

The whole model rests on one clean line. A live session is a draft: fluid, multiplayer, ephemeral, and never hashed. A commit is a frozen, content-addressed version — and only a commit is citable, reproducible by URL, and safe to build on. When you need to point a colleague, a paper, or your future self at an exact result, you commit and share the snapshot, not the session.