doclayer / guide

doclayer · how the demo works

doclayer is a meta-harness for collaborative writing. Two writers and three AI agents share a series; the editor reshapes itself per phase, per author, and per task. When the article ships, the same document grammar becomes a reader-harness — the page re-binds to each reader's prior knowledge.

The mocks below are static HTML with CSS animations and auto-play on load. This guide tells you what to watch and why.

10 scenarios · ~6 minutes to walk the whole arc · suggested viewing order below
recommended viewing order

Walk the arc top-down.

The lifecycle reel sets context for everything else. The protocol loop (09) is the actual mechanism. The two canonical views (07, 08) show the system from one shared moment and across a series. Single-author slices (01–05) zoom into the grammar atoms. Reader-harness (06) is what ships.

  1. Lifecycle reel

    scenario 00 · ~2 min

    Start here. End-to-end playthrough: trajectory generation → two-window parallel work → cross-collab handoff → single-article publish → reader-harness. One continuous reel; everything else is a zoom.

    open 00-flow →
  2. The review loop, end-to-end

    scenario 09 · the protocol

    The protocol in 30s. Type → AI inline augments → notification → reviewer's harness reshapes → comments back → author iterates. This is the actual mechanism the meta-harness arranges.

    open 09-review-loop →
  3. Multiplayer, two-up

    scenario 07 · canonical

    In-the-moment view. Two writers, different sections of the same chain, two structurally different harnesses authored from each author's prior. Sync gutter routes cross-collab as reviews.

    open 07-multiplayer →
  4. Workstream across lanes

    scenario 08 · canonical

    The canonical lanes view. Series spine across 4 articles, per-author work queues, and 3 AI agents (research, adversarial, visual) orchestrating in the middle. The harness arranges the work, not just the chrome.

    open 08-workstream →
  5. Single-author slices

    scenarios 01–05

    Zoom into one author's view of each phase: bootstrap (01), planning (02), drafting (03), review (04), publish (05). Useful for seeing the grammar atoms in detail without the multiplayer overhead.

    open 01-bootstrap →
  6. Reader-harness

    scenario 06 · what ships

    The published article re-renders per reader prior. Same atoms; three different binds. The doc becomes the reader's harness.

    open 06-reader-harness →
scenario notes

What to watch for, scene by scene.

Each scenario has a small ? guide button in the lower-left that opens a timed-beat narration synced to the on-page animation. The summaries below are static.

scenario 00

Lifecycle reel

The doc, born and shipped in one continuous reel.

proves: the whole system in one breath. Lifecycle is a single continuous mechanism, not five disjoint apps. open scenario →
scenario 01

Bootstrap

Empty workspace → grammar atoms snap into a layout.

proves: the editor isn't a template — it's authored from the manifest. open scenario →
scenario 02

Planning graph

Evidence, owners, and unresolved holes before prose exists.

proves: planning stabilizes what to write before the system helps write it. open scenario →
scenario 03

Drafting

A blocked sentence opens continuations, then returns to writing.

proves: drafting is local intent switching around a stalled sentence. open scenario →
scenario 04

Review

Accept, reject, route, and gate the section for publish.

proves: review routes decisions and gates publish instead of drafting more prose. open scenario →
scenario 05

Publish

Preview cycles priors. One button ships to doclayer.live.

proves: publish is a build, not an export. The output is a harness, not a static page. open scenario →
scenario 06

Reader harness

The doc becomes the reader's harness.

proves: the article itself is a harness. The reader's browser binds against the grammar. open scenario →
scenario 07

Multiplayer, two harnesses

In-the-moment view. 02–05 are slices of this.

proves: "multiplayer" doesn't mean "shared view" — it means shared chain, separate harnesses. open scenario →
scenario 08

Workstream across lanes

Series spine, two writer lanes, three AI agents.

proves: doclayer is a workstream, not just an editor. Agents and writers share lanes. open scenario →
scenario 09

The review loop, end-to-end

One full protocol cycle, ~30 seconds, both sides visible.

proves: the protocol is symmetric. Either side's harness reshapes on receive, not on send. open scenario →
cross-browse

Browse other viewers' variants.

Every signed-in viewer who's applied a patch has a personalized variant of the harness — a divergent copy driven by their comments. The variants gallery lets you walk through someone else's variant read-only and diff it against canonical.

variants gallery
Open the gallery to see who's diverged how. Click any card to load that variant's patches against the live mocks. A pink banner makes the read-only mode unmistakable.
open gallery →
concepts

Glossary.

The vocabulary that turns up across the scenarios.

harness
The runtime around the model. UI shell, intent state, agent routing, panel layout — everything the model isn't, but everything that lets it be useful.
meta-harness
A controller that authors controllers. doclayer is one: it composes per-phase, per-author, per-task harnesses from a document grammar.
document grammar
The typed atoms the architect emits. Title, section, claim, citation, lesson, comment. Atoms bind layouts; layouts don't define atoms.
lane
A per-user task queue. Each writer has one; the series spine sits above them. Agents fire into lanes from a shared orchestration rail.
AI agents
Three: research (citation surfacing), adversarial (claim-checking, contradiction-flagging), visual (diagrams, callouts). Each augments writers inline.
cross-collab
Review and comment routing between authors. The architect packs a section as a packet; the receiving harness reshapes on receive.
reader-harness
What ships. The published article is a tiny harness that re-binds the grammar against each reader's prior. Same atoms, structurally different page.
lesson memory
Dismissed suggestions and accepted edits compose into lessons. Lessons rerun the suggester with a new prior. The model learns the writer's taste.