One live document, people and the assistant together

A Tuesday afternoon on one client page. You are typing a new paragraph in the executive summary. A colleague on hotel wifi that keeps dropping is editing the pricing table. The assistant has been asked to remove a redundant table and tighten the opening.

All three land. The paragraph, the table edits made while offline, and the assistant’s restructuring merge into one document. Every browser shows the same page, and nobody’s cursor jumps.

A page is a CRDT, and that decides everything else

Actionary holds a page as a conflict-free replicated data type. Every participant keeps their own copy and records what they did as operations carrying identity — insert this, here, by this writer. Copies exchange operations and converge on the same result in any order, with no central referee deciding who wins. It is the data structure behind modern collaborative editors, and the successor to the operational transformation lineage that made shared documents work in the first place.

The document layer is yrs, the Rust implementation of Yjs, driven server-side from Python through pycrdt and bound to the editor through y-prosemirror. The same pairing of pycrdt and an async Python server runs Jupyter’s real-time collaboration, where many people share one live notebook.

The assistant is held to the same contract as a person

This is the part that matters for an agent-first product. When the assistant edits a page, its change is applied as operations inside the shared document, so it travels every path a keystroke already travels: every open browser receives it over the document connection, every server replica receives it over a per-room channel, and it is saved on the same debounce that saves typing. There is one write path, and the assistant uses it.

The consequence is visible. Ask the assistant to restructure a section while two people are working in it, and the page changes under everyone at once. Their sentences survive. Its restructuring survives. Everybody converges on the same document.

A page is a standard entity, so the assistant reaches it through the same entity-config contract, the same permission gates and the same audit trail as every other record. There is no document-specific tool surface and no second security model.

Working offline is working, not queueing

The document is kept in the browser. Close a laptop on a train, reopen it in a tunnel, keep writing — the work is there, still offline, and merges when the connection returns. A poor connection is an ordinary condition rather than an interruption: drops are reported only when they persist, because a flapping connection that announces every blip is noise.

Presence, cursors, and comments that stay put

Live avatars and carets ride the awareness protocol on the same connection, each labelled with the name that person carries everywhere else in the product.

Comments anchor into the document itself rather than to a stored offset, so a thread stays welded to the sentence it is about through every edit around it — text typed above it, a paragraph split around it, the sentence rewritten inside it. Offsets held in a column are wrong at the next keystroke. Commenting follows editing: a grant of “Can edit” carries commenting, replying and resolving with it, so there is no separate permission catalogue to configure.

Built to hold at scale

Rooms are keyed on tenant and record, and the name is assembled server-side from the connection’s own session, so one tenant cannot name its way into another’s document. Two people landing on different replicas behind the load balancer stay on one document through a per-room channel. A room costs memory only while somebody is in it, and writes are debounced — a burst of typing is one write rather than one per character.

What this replaces