DeepBuild, Under the Hood
Where your agents show, not tell.
The design as it stands (draft 6.9.40): the choices, the trade-offs, the use cases, how to extend it, and what’s still open.
Keep the order total above the fold on phones?
Work goes on with “keep” · default in 3 days · undoable
Vibe Visuals: Describe It, Agents Show You
Like vibe coding, except the result is a picture, a film or a scene, made as data so it can be checked and fixed like code.
What Vibe Visuals Is, and What It Is Not
The edges of the idea, from the owner’s own corrections during the design.
What it is
What the owner ruled out
One Person, 548 Sessions a Month, No Way to See Them
Before designing, we measured one heavy user’s agent history: 947 sessions in one scan, 548 in a 30-day recheck.
sessions at once in one repo (median 28 a day)
of 548 sessions in the recheck had an “is it done?” follow-up
stops that ended on a question to you
of your replies were a bare “yes”
sessions ran in the desktop apps, not terminals
of 8,137 prompts were about parallel collisions; in one incident, a pkill took down a sibling’s stack
An Hour With Three Agents and DeepBuild
Three agents, one hour, read 1 to 6. Each box is what you would see; its last line is what you had to do.
It becomes a card in the app. The agent does not stop to wait; it carries on with the default.
total.ts:42DeepBuild itself runs the tests and a checkout journey in a browser. The failure goes back with the line to fix.
Only check results count as proof, so this PR is allowed to say the issue is closed.
The agent writes a short document: three shots, numbers taken from the test run. DeepBuild draws it and checks it.
DeepBuild sees every command before it runs. This one is blocked, and the agent is told why.
main in api.Pushing to main needs your authority, so this is the one thing that waited for you.
Words You’ll See (1 of 5): How Work Reaches DeepBuild
Follow one session: what it does (left), how it reaches DeepBuild (middle), the log row each step adds (right).
Agent session
One run of Claude Code or Codex working on one thing.
claude in checkout-web, fixing #42Hook
A command the agent runs by itself at fixed moments: start, your prompt, before and after a tool, a stop. DeepBuild’s is deep-hook.
PreToolUse → deep-hookMCP tool
An optional function the agent may call mid-task, over MCP, the usual tool protocol. If it never does, hooks still catch its questions and claims.
deep_ask · deep_showRecord
DeepBuild’s log of everything that happened. Rows are added, never changed.
claim.made · run.finishedWords You’ll See (2 of 5): Session, Task, Turn and Stop
A session holds tasks; a task takes turns; a turn ends at a stop. The done gate acts at each stop.
Session
One run of Claude Code or Codex. It can stay open for days and carry several tasks.
claude · checkout-webTask
One request that changes behavior. It gets one definition of done and usually spans several turns.
#42 · #43Turn
One request and its response: from your message until the agent replies. Not a finished job.
“yes” → … → replyStop
The agent ends its response: the Stop hook fires. A send-back makes it go on in the same turn, so a turn can hold two stops.
Stop hookWords You’ll See (3 of 5): How “Done” Is Judged
Read left to right: one bug fix, from what done means to the result. The four yellow labels are the four words.
Definition of done
The checks that will judge a task, written down at its start, from your words.
#42: receipt = cart totalClaim
A stop where the agent did work, read as “I did it”.
Stop after editing total.tsCheck
A test, a command or a journey (a scripted run through your app in a browser) that DeepBuild runs itself.
npm test · checkout journeyVerdict
One of five results for a claim, earned from checks only.
PASS · FAIL · and three moreWords You’ll See (4 of 5): Asked Once, Then Remembered
Top: you answer a question once, and DeepBuild saves it. Bottom: next week another agent asks the same kind; no ping.
Ask
A question only you can answer. It has a deadline and a safe default, so no agent waits forever.
push to main? default no, in 1 dayDecision
Your answer, saved and matched by kind and scope, never by exact wording.
merge own fix PR · checkout-webSix kinds of ask
Authority, taste, choice, unblock, exception, what done means. A repeat taste call asks again until you accept a rule (later).
authority · taste · unblock · …What agents can’t do
Create, change or widen a decision. Only your answer on a card makes one.
agent edits a decision → deniedWords You’ll See (5 of 5): Sharing One Mac, Drawing From Data
Left: two sessions want the same port. Right: an agent sends a few lines of data, the canvas draws them, and a one-value patch changes one bar.
Lease
A shared thing one session holds so another can’t collide with it.
port 3000, held by apiWhy leases
A real pkill once took down a sibling session’s stack, and two worktrees fought over one port.
refused, names the holderDocument
Data the canvas draws: a figure, a film, a scene, a map. Agents send documents, never pixels.
items/q3/params/value: 48Why documents
Data can be checked, replayed and patched one value at a time. Pixels can’t.
patch: 48 → 52Eight Parts, One Map
Parts 1 and 3 say what DeepBuild is; 2 and 4, how it works with you; 5, how it grows; 6 to 8: use, the build, open work.
The Running Index (1 of 4): Introduction to See and Steer
The Running Index (2 of 4): Make
The Running Index (3 of 4): Trust, Extend, In Use
The Running Index (4 of 4): Build It Right and What’s Open
Part 1: Foundation
What DeepBuild is built from, the rules every part keeps, and its first trade-offs: logic, storage, processes.
Four Parts, and One Agent Stop Passing Through Them
Four programs. Follow one agent stop through them, 1 to 5. R1 is the first release (version 0); R2 the next.
DeepBuild, Taken Apart: Every Part on One Tree
The four parts from the last slide, opened one level down. Each box names its job and the slide that explains it.
Four Jobs, One Record Under All of Them
What the four parts do for you, as four jobs. Each box’s last line names the parts and the release; all use the record.
Six Releases: What Version 0 Builds, and What Waits
The four jobs don’t all arrive at once. R1, version 0, builds the core; each later release adds to it.
deep command.Four Invariants Every Part Must Keep
All four jobs, and every plug-in, keep four rules. Each column: the rule, what it means, and one catch.
An agent’s word is never evidence
Only check results count. Why a session stopped is read from hook payloads, never its text.
→ changes nothing
Nothing missing or unrun passes
A check that ran nothing, couldn’t fail or lost its results never passes. It gets a named non-pass verdict.
npm test || true→ INVALID, naming the mask
Agents can’t change checks or decisions
Agents can’t edit the checks in .deepbuild/; your decisions live outside every repo.
→ denied; it can only propose
Only what needs a person, never twice
Asks sorted by kind; saved decisions answer repeats by kind and scope.
→ decided for you, logged
Rule 2 in Practice: Silence Is Never a Pass
Six ways a check can look green while proving nothing. Each row: what happened, the naive reading (struck out), and DeepBuild’s verdict.
npm test → exit 0, “0 tests”
"test": "vitest || true"
|| true; it can’t failcontinue-on-error
Inside the Hub: The Core, the Ring, Extensions, Plug-ins
The hub, opened one level down. Highlighted: the part the next slides explain first.
One Hub per User: The Program That Keeps the Record
The hub is DeepBuild’s one long-running program. Follow 1 to 4: it starts, agents and you connect, it writes the record.
Why One Hub for All Your Sessions, Always Running
Three jobs no session or short-lived script can do. Each row plays an example; the right box says why.
deep-hook: Tiny Because Every Tool Call Runs It
deep-hook carries each hook call to the hub. Top: one call, 1 to 4. Bottom: hub down, and the agent still goes on.
It can append events and read fast rules, the few deny rules kept in a local file. It never holds the control token, so it can’t answer for you.
Estimates until week 1 measures again: on the owner’s Mac a native binary started in about 27 ms, Node 52, Python 75, paid per call.
Targets: under 10 ms at p95 over process start, except holds. The hub acks each call within 20 ms; no ack by 50 ms counts as down.
deep-hook and the Hub on the Wire: Request, Ack, Reply
The last slide’s steps 2 to 4, as the bytes on the socket: a request line, an ack within 20 ms, then the reply.
Only an acked hold waits
No ack by 50 ms, or no reply by the hold_until_ms the ack set: deep-hook acts as if the hub were down.
Refused counts as down
A request the hub refuses, or a reply that won’t parse: fail-closed rules, allow the rest, spool it.
seq travels as digits
1760013451123456789 as a JavaScript number becomes …768, so it is a string, compared as an exact integer.
Hub Down: The Spool Keeps Each Event and Replays It Once
The silent-hub row, followed on: what deep-hook writes while the hub is down, and what the hub does at start.
Old stamps, new numbers
Each line takes the next log_pos, the record’s line number, so a reader that resumes after its last one still gets it.
Each ID once
A hub that crashed mid-replay reads the file again; an ID already in the record is skipped.
Saved first
A commit that waits until it is on the disk itself, so a power cut can’t lose it (more in 48).
Where the Logic Lives: What We Compare, and Why
Before the scores on “Where the Logic Lives”: each row is one column of the next slide’s table, and why it matters.
Where the Logic Lives: Only a Resident Hub Can Answer Hours Later
Four ways to place DeepBuild’s logic, scored on the columns the previous slide explains.
Which Language Where: What We Compare, and Why
Before the scores on “Which Language Where”: each row is one column of the next slide’s table, and why it matters.
Rust Where It Runs Often, TypeScript Where It Changes Often
Left: start time per language, paid on every hook call, so deep-hook is Rust. Right: the hub’s language, scored.
What an Extension Is, and Who Writes One
The hub stays small; features on top are extensions. Left: the two parts that never are. Right: who writes them.
Extension
Any feature built on top of the core, even DeepBuild’s own; those are pinned and checked before they load.
Done gate · journey
The done gate runs checks a blind job wrote from the old code, and only their results judge a stop. A journey is a scripted browser run of your app.
Resolver · adapter
A resolver answers a repeat ask from your saved decisions. An adapter reads one agent’s hooks and replies.
Wiki · plug-in
The wiki keeps what DeepBuild learns about you. A plug-in is an extension your agent or someone else wrote.
In-Process or Sandboxed: Where Each Extension Runs
Left: DeepBuild’s own extensions, inside the hub. Right: an extension your agent built, in its own fenced program.
In-process
Loaded into the hub’s own program, like a library. Fast, and fully trusted.
first-party TypeScript onlyOut of process
Runs as its own program that the hub starts and talks to by messages. A crash can’t take the hub down.
agent-built · third partySandboxed
The operating system fences that program in: only the hosts, folders and keys it was granted.
Seatbelt · bubblewrap · AppContainerWhy split
Putting everything inside would trust agent code fully; putting everything outside would slow the check at every stop.
split by who wrote itFive Ways In, All Onto the Same Hub
The hub’s callers from slide 24, plus plug-ins: five ways in. Each card’s last line says where its power stops.
Hooks
Every agent, at every step. You never call it.
PreToolUseStopSessionStartlimit: can only append events and read fast rules
MCP tools
When an agent needs something mid-task.
deep_askdeep_showdeep_claimlimit: reaches only its own session; can ask, never decide
CLI
From a terminal, CI or a script.
deep statusdeep inboxdeep doctorlimit: authority or a saved decision counts only after Touch ID
App
To see every session and answer what needs you.
Needs youthe linethe Maplimit: the question card nothing can cover
Plug-in API
To add a check, a source, a view or a channel.
registerCheckregisterSourceregisterViewlimit: only what its grant allows, enforced
Which One Is Used When
Start at the top and follow the first yes. Each answer comes with a concrete example of that surface in use.
How Each Way In Reaches the Hub, and What It Proves
The last slide said which way in is used when. Here: how each reaches the hub’s socket, and who it proves it is.
What a Hook Is: The Agent Calls Us at Five Moments
Slide 6’s hook in full: at five moments of each turn, the agent runs deep-hook, which records it and may answer.
Why Hooks Can’t Be Taken Literally: Five Real Cases
A hook says one moment happened, not what the agent is doing now. Read literally, five ordinary cases mislead.
Stop fires while the main agent keeps editing
“checkout-web is done”Checks who fired it: the helper stopped, the main agent is still working.PostToolUse lands after the turn’s Stop
“the finished session started again”Orders events by the time deep-hook stamped each one; the late event stays in its own turn./clearthe session gets a brand-new ID
“new session”, and your open question vanishesJoins the old and new IDs into one thread; the question follows it.Every Agent’s Events, Mapped Onto the Same Few Shapes
Read carefully, a hook still speaks its agent’s dialect. Its adapter maps it onto shapes that every rule shares.
What If an Agent Never Calls the MCP Tools?
Nothing breaks: the hooks catch every claim and question on their own. The tools are extras an agent may use.
If called: it asks mid-turn and hears the ask’s deadline and default, with “still waiting” before its tool times out.
If never: a question it stops on, or a question card, still becomes an ask.
If called: it records what the agent expects each check to show, so a story made up later shows as a contradiction.
If never: the Stop hook still makes the claim, and the checks still run.
If called: it draws a figure on the agent’s claim or ask; you see it when you open it.
If never: nothing is drawn and nothing is lost: a picture is never proof.
How a deep_ask Call Finds Its Session
When an agent does call a tool, the hub must know which session is asking. Two cases; the hooks settle both.
Never by PID alone
The OS reuses PIDs, so a parent is known by its PID and its start time together.
One stamp, one call
Each stamped event binds at most one call. Where the adapter can edit a call’s input, a one-time code added to it does the job.
Ends with its session
At SessionEnd, when the parent exits or the attempt is replaced. A successor never inherits it.
The Record: Write Down What Happened, Never Edit It
What hooks catch goes into the record. Left: an edited table loses the story. Right: DeepBuild’s log keeps it.
A Projection: A Table Rebuilt by Replaying the Log
Views need tables, not a list of lines. A projection is a table the hub builds by replaying the log, in order.
One Log, Many Tables: Every View Reads the Same Lines
Left: who adds lines, via the hub. Middle: the log; each line’s number is its log_pos. Right: tables rebuilt from it.
One Hook Line Into the Record: Read, Parse, Commit, Send
The last slide’s 5,000 lines a second, one line up close: three threads in the hub, then when it is on disk.
Why off the loop
One huge tool output never holds up another session’s hook: parsing and disk waits run elsewhere.
Saved first, or in batches
A cut can lose busy tool-call lines (the claim then can’t PASS), never a verdict or an answer.
Gaps never fill
Positions commit in order, so a gap a reader sees stays empty for good.
Every Table Reads Only the Log: No Clock, No Files
Committed lines feed the tables, and one rule keeps each rebuild equal: a table reads events, never the clock.
Reads nothing else
A projection reads its events in log_pos order: no clock, setting, file or evidence bytes.
Time comes as events
A defaulted ask or a stale lease comes from an event that says so, never from a table reading the time.
Forward only
Each event kind carries a schema version. Migrations only move forward, and every table can be rebuilt.
What If the Hub Restarts or the Power Fails?
Left: line numbers let the app pick up exactly where it left off. Right: what a power cut can lose, and can’t.
How the App Reads the Record: Read Once, Then Follow
The last slide’s app, from its first read: each read says where it stands, and the stream picks up from there.
Reads say where they stand
Every read returns the log_pos it reflects, so nothing appended between the read and the stream is missed.
A new start ID: read again
Each hub start gets a new ID. Frames from before a power cut may be gone, so the reader starts over, never resumes.
One reader
A guard in the app’s local preflight fails any other module that subscribes to the stream or calls the reads.
Evidence: Stored by Its Hash, Checked at the Door
The log says what happened; evidence files prove it. Each is named by its hash and checked when it arrives.
Named by its hash
Stored once under its SHA-256, so a receipt that cites a hash can’t point at a swapped file.
ev:sha256…
Kept 30 days
Except evidence behind a decision or an archived transcript. A verdict whose evidence is gone is never reused: a later claim runs its checks again, and the old verdict stays as recorded.
A pasted image counts
Stored by hash with its message: a bug report becomes a check, a taste remark a decision with that image as its baseline.
Each line names its proof
The agent’s statement, a static check, a test run, a real journey or your decision. A lower one never shows as higher.
Privacy: Secrets Scrubbed by Value, Files Leave by Hash
Before a file is hashed, every secret value DeepBuild knows is scrubbed. Nothing leaves the Mac by default.
By value, not just pattern
The exact values it injected or holds by handle, and variables named like TOKEN, KEY, SECRET, PASSWORD or AUTH.
Short values stay
CI=true, NODE_ENV=test, TZ=UTC or a leased port are left as they are.
CI=true
Your folder only
A path an agent names outside its working folder is answered as if it didn’t exist.
Content-free mode
Keeps only counts, durations, error signatures and verdicts, never text.
Storage: What We Compare, and Why
Before the scores on “Storage”: each row is one column of the next slide’s table, and why it matters.
Storage: An Append-Only Log Makes Every Verdict Auditable
Four ways to store what happened, scored on the columns the previous slide explains.
Processes on One Mac: Who Started Each, Who May Stop It
DeepBuild starts checks and test servers for agents, on a Mac many sessions share. Each process has one owner.
Supervisor
The part of the hub that starts every process DeepBuild runs: checks, test servers, sandboxed plug-ins. It stops only what it started.
Run token
A label the supervisor puts in each process it starts, so the hub can later prove the process is its own.
The agent’s own
What Claude Code or Codex starts by itself stays theirs. DeepBuild never stops it; deep-hook only refuses kill-by-name.
Lease, again
Port 3000 stays leased to api until every process the supervisor recorded for it is proven gone.
Why Never Kill by Name: One pkill, Two Sessions
Codex restarts its server the usual way. Left: what that does on a shared Mac. Right: what deep-hook does.
How a Process Is Known: Run Token, Start Time, Group
The hub’s supervisor labels each process it starts for an agent; each label answers one question.
The supervisor puts it in the environment of each process it starts. The start is logged before the process exists, then again with its PID and start time.
The OS reuses PIDs, so a PID file can point at a stranger. A PID plus its start time names exactly one process.
Each process it starts gets its own group (a job object on Windows). Before any stop the hub checks the token, the start time and every member. A child that left the group is still known by its token, or by the fork the supervisor saw.
deep env up, Step by Step: The Lease, Then Each Process
Those labels go on at the start: Codex runs deep env up, and the hub leases the port before it starts anything.
Cleanup: Stop Exactly What Was Started, Prove It Gone
Codex runs deep env down: the supervisor stops token 7f3a’s processes, leaves the rest, then frees the port.
Knowing Our Own Processes: What We Compare, and Why
Before the scores on “Knowing Our Own Processes”: each row is one column of the next slide’s table, and why it matters.
How DeepBuild Knows Which Processes Are Its Own
Three ways to clean up after checks and environments, scored on what each column measures and why it matters.
macOS First, but Every Platform Part Sits Behind One Seam
Each place DeepBuild touches the OS is a seam: one interface, one backend per OS. Rows: seams; columns: backends.
| Seam | macOS (first) | Linux (R2 hub, R3 app) | Windows (after R1) |
|---|---|---|---|
| Local socket | Unix socket, mode 0600 | Unix socket | named pipe, your user |
| Secret store | Keychain | Secret Service | Credential Manager |
| Process ownership | process groups, fork watch | a cgroup per run | job objects |
| Undoable deletes | APFS copy-on-write | btrfs or XFS | ReFS |
| Starts at login | launchd | systemd user service | logon task |
| Sandbox | Seatbelt | bubblewrap + Landlock | AppContainer |
| Sharing GPU pictures | IOSurface | shared wgpu device or DMA-BUF | DXGI shared handle |
| Audio, capture | CoreAudio, ScreenCaptureKit | PipeWire, portal | WASAPI, Graphics.Capture |
Part 2: See and Steer
Part 1 built the hub and its record. Part 2: what the app shows you of it, how a question reaches you once, and how your answer gets back.
Inside the App: Shell, Views, and the Canvas Core
The app, opened one level down. Highlighted: what the next slides show.
The App: Every Session, What Needs You, and Each Session’s Line
The DeepBuild app draws the hub’s record: sessions by repo, Needs you (the asks waiting on you), one session’s page.
A Session’s Line: Issue #42 to PR #57, Stop by Stop
The line from that page, up close: the app draws Claude Code’s session as a dot that colors each stop it passes.
Drawn from the record
Every stop links to the events behind it, so the line shows only what happened.
Colors are states
Red: its checks failed. Yellow: it waits on you. It says “says done” until checks back the claim.
On a session’s page
Tabs for its line, its asks and its checks (from R2, a terminal tab when the hub hosts it), plus a box that talks to the agent.
The Map is many lines
Journeys are lines and code parts are stations, so a project reads like a transit map.
The Same Line for Work That Isn’t Code (R2)
From R2 (the release after the first, R1), a weekly report an agent writes runs the same line as code.
Where it lives
A workspace: a git repo DeepBuild keeps under ~/.deepbuild/workspaces/, so history and undo work as in a repo.
What it is pinned to
A commit plus digests of what its sources read. If a source it read changes, its verdicts go stale and only affected checks rerun.
Writing has no machine proof
So done means the numbers are checked and you made the taste call. A model’s opinion is never a verdict.
What You Can Change About a Line, and When
Top: a playbook, a custom line. Below: what each part of a line can be, tagged by release (R1 is the first).
1 · Where it starts
2 · What proves it
3 · Where it ends
4 · Its steps
deep create R6lanes in parallel R6a blueprint: “close the month” R6An Ask, by Example: One Card, a Deadline, a Safe Default
The You stop on a line is an ask. Up close: Codex asks to push; the hub makes one card, with a deadline and a default.
Every Ask Ends (1 of 2): Six Kinds, Six Clocks
The hub gives each of the six kinds its own clock. Bar: how long it waits for you; box: what it applies if you never answer.
done.yaml overrides them key by key; a value nobody declared makes what needs it BLOCKEDEvery Ask Ends (2 of 2): None Expires Unseen
No default lands unseen: the hub holds each ask for your next visit, or shows it at once if its deadline comes first.
Past the deadline
To the fallback: the owner of the change, then the queue you named. For one person, no one is above you, so the default applies.
claims a default can pass
A default is announced, recorded as “defaulted”, and undoable from Needs you.
open asks per session
After five, its further asks fold into one: “this session keeps asking”. Answer it in bulk, pause, or leave it.
thread per ask
On every channel: the app now, your phone or a chat app from R2. Answer anywhere; it closes everywhere.
A Task Only You Can Do, and Why It Closes Itself
Of the six kinds, unblock is a step only you can take. It names the check that proves it, so it closes itself.
What a task says
What to do and where, why it’s needed, what it unblocks, and the check that will prove it’s done.
Never a link to click
A sign-in names a provider or a secret; the trusted path supplies where to go. Other URLs show as plain text.
One cause, one task
Sessions stopped by one cause share one task, read from the stop’s closed set of causes, never from text.
One automatic continue
Only from the newest stop, under 10 minutes old, and only if nothing you typed has reached it since.
How One Question Travels (1 of 3): Four Gates, Then You
The hub tries four gates first. Follow a taste call from Claude Code; grey boxes show what each gate settles.
How One Question Travels (2 of 3): Reads and Writes
The four gates, then Needs you and delivery, as the hub runs them. A resolver is a plug-in that may answer for you.
How One Question Travels (3 of 3): The Resolver Contract
Gate 2 up close: a resolver is one function a plug-in hands the hub; the core checks its reason before answering for you.
Two answers disagree
Neither applies. You see both, and your answer overrules the other only at that ask’s scope.
Also accepted
A request you typed in that thread. For an unblock: the tool, grant, lease or credential to use.
Rules are scored
Each saved decision acts as a rule. If the work it decided breaks more often than yours, it is revoked.
What Your Words Authorize: “Create PR” Is Not a Merge
A request you typed can answer an ask, as the last slide said. It covers only what it names, in that thread.
Exactly what it names
“Create PR” covers the push and the PR. Anything it doesn’t name is still an authority ask.
In that thread only
The request answers asks in the thread you typed it in, never in another session.
By what a call does
The core sorts calls by effect: push, merge, dispatch, send, delete. gh or an MCP tool, same rule.
Typed by you
Text that merely shows up in a session’s prompt never authorizes anything.
Plans Before Acting: Every Step Shown Before Your Yes (R2)
Each authority ask, like that merge card, carries a plan: the steps, what each changes, its undo and cost.
Matching Questions: What We Compare, and Why
Before the scores on “Matching Questions”: each row is one column of the next slide’s table, and why it matters.
Matching Questions and Ending Waits
Two choices the hub makes: how a saved answer matches a new ask, and what happens when nobody answers.
How an Ask Gets Its Key: Fields, Never Words
Kind and scope won. The hub turns them into a key built from the ask’s fields; its wording never enters it.
Choices and definitions
Their key is the requirement or decision point the ask is pinned to, with its options’ IDs.
One canonical form
The fields are hashed as RFC 8785 bytes, so the same fields always give the same key.
Tested on near misses
A fixture file per kind: pairs that must share a key, and near misses (another screen, owner or option) that must not.
Getting Your Answer Back (1 of 4): It Must Find Its Session
You answer on your phone, hours after an agent asked. Your answer still has to reach that one session.
The hub keeps it
Your answer is recorded the moment you tap, so a closed laptop or a quit app loses nothing.
A hook is the only way in
DeepBuild reaches a session only when the agent calls it: as it stops, through a waiting hook, or with your next message.
Never an interrupt
Stopping a turn to deliver an answer is not allowed. The agent always finishes its step first.
Getting Your Answer Back (2 of 4): Three Doors Into Claude Code
Which door opens depends on what the session is doing when your answer lands. One row each, with an example.
The Waiter: How an Idle Claude Code Session Wakes
Door 2 up close: a waiter is a hook that sleeps beside the idle session and exits to wake it when you answer.
Its timeout is set long
Claude Code stops a hook at its timeout, 600 s unless set, so setup gives the waiter the longest ask deadline, 3 days.
One per session
A new waiter replaces the old one, which exits without waking. It watches its parent, so it can’t outlive a headless session.
Measured once
1.4 s to wake, from a claude -p script on Oct 4. Waking an interactive session, or the desktop app, is unmeasured.
Getting Your Answer Back (3 of 4): Each Agent’s Doors
Not every agent lets a hook wake it. Which doors each agent has today: ✓ yes, ✕ no, – not offered.
| Agent | Hold the stop | Wake when idle | Steer mid-turn | Next message | Why |
|---|---|---|---|---|---|
| Claude Code terminal | ✓ | ✓ | ✓ | ✓ | the three doors of the last slide; while it works, its next tool call |
| Codex CLI terminal | ✓ | ✕ | ✓ | ✓ | its next tool call while it works; its stop can wait up to 45 min; a background hook can’t start a turn |
| Codex app desktop | ✕ | ✕ | – | ✓ | watch-only until its hooks are seen firing there; then as the CLI |
| pi, paseo (R2) driven | ✓ | ✓ | ✓ | ✓ | steers a running turn, or starts the next one when idle |
Picked per session
A door counts only once that session has shown it works, for example its hook seen firing; otherwise the next one down.
Steer, never interrupt
Where an agent allows it, an answer can join a running turn at its next step. DeepBuild never stops a turn to deliver.
Who Waits for Whom: The Agent’s Clock, Not Ours
DeepBuild waits only inside the agent’s hooks and tools, and the agent stops each after a set time.
The agent still waits for you
When a turn ends, Claude Code waits for your next message, as today. DeepBuild never makes it wait longer.
The time limits are the agent’s
Claude Code and Codex stop a hook or tool call that runs too long. These are their settings, not DeepBuild’s.
So every wait ends early
A hook cut off mid-hold would let “done” through unjudged, so each DeepBuild wait ends before the agent’s limit.
Getting Your Answer Back (4 of 4): Timing Rules
The agent’s own time limits, one per row: what DeepBuild waits for, the limit it fits inside, and what if not.
deep doctora broken rule is never silent: its route turns watch-only (record, never hold) or falls back, naming both timesA Taste Call Mid-Turn (1 of 2): The Agent Keeps Working
Asks and delivery in one story. Codex hits a taste call mid-task; deep-hook and the hub tell it to go on. Follow 1 to 7.
Provisional
Work goes on with the recommended option at once, marked as undoable. Your answer can still change it.
What waits
Only steps that leave the machine, such as a push. Everything local goes ahead.
The notification
Carries the question, its default and when it applies. It opens the card; it answers nothing.
A Taste Call Mid-Turn (2 of 2): You Answer Once
You answer later, on your phone. Follow 8 to 13: the hub saves it, and Codex’s adapter steers it into the live turn.
Saved, matched by kind
A saved answer settles repeats of kinds like a merge. A taste call repeats until you accept a rule (later).
Steer, never interrupt
Your answer joins the running turn and is read at Codex’s next step.
Confirmed
Delivery counts only once the agent’s transcript shows it got the answer.
The App: What We Compare, and Why
Before the scores on “The App”: each row is one column of the next slide’s table, and why it matters.
The App: Native and GPU-Drawn, Decided by a Two-Day Spike
Four toolkits that could draw the DeepBuild app, scored. Chosen: gpui-kit, a Rust toolkit that draws on the GPU.
Where Code Runs (1 of 2): Three Rings of Trust
As in Part 1, who wrote a piece of code decides where it runs. The nearer the middle, the more that code may do.
Where Code Runs (2 of 2): Nothing Covers the Question Card
The ring’s most guarded part. Left: a view your agent wrote tries to fake a Yes on the card. Right: who draws what.
Where Plug-in Code Runs: What We Compare, and Why
Before the scores on “Where Plug-in Code Runs”: each row is one column of the next slide’s table, and why it matters.
Where Plug-in Code Runs: Split by Who Wrote It
Four ways the hub could host plug-ins. Chosen: DeepBuild’s own code inside, your agent’s code fenced off.
Part 3: Make: Vibe Visuals
Parts 1 and 2: how DeepBuild records agents’ work and asks you only what needs you. Part 3: how agents show that work as pictures made of data, which DeepBuild’s canvas checks and draws.
Primer: The Canvas Is Where Agents Show Their Work
The DeepBuild app, simplified. An agent sends a few lines of data; the canvas draws them inside the app’s window.
What it is
The app’s one drawing surface: every session’s line, the Map, charts, terminals and agents’ figures.
Who draws on it
Only the canvas core, DeepBuild’s trusted drawing code. Agents and plug-ins only send it documents.
What it never does
Push a picture at you, count a picture as proof, or draw over the question card.
Where it runs
Inside the DeepBuild app’s window on your machine, drawn with your own GPU.
What Agents Make: Ten Kinds of Picture, One Canvas
What agents can ask DeepBuild’s canvas to draw, from a chart to a small game, and the release each lands in.
Who Would Use It (1 of 2): Engineers to Researchers
Who would have agents draw these in DeepBuild: four kinds of people here, four next. Each picture plays item one.
Who Would Use It (2 of 2): Teachers to Game Makers
The other four. Again, each picture plays the first thing on that person’s list.
Use Cases the Owner Asked For (1 of 2): Agents and Plug-ins
Now the owner’s own 24 requests, in four groups. Here: running many agents, and one-sentence plug-ins.
Use Cases the Owner Asked For (2 of 2): Explain, Make, Play
The other two groups: pictures that explain and teach, and pieces to watch, share and play.
Primer: Rendering Draws Pixels, One Frame at a Time
Three primers before the canvas. First, drawing: a description becomes colored dots; motion is many timed frames.
Pixel
One dot of color. A 1920 × 1080 picture has 2,073,600 of them.
Rendering
Working out each pixel’s color from a description, such as “a yellow bar, 48 high”.
Frame
One finished still picture. Motion is many frames shown one after another.
Frame rate
Frames per second, written Hz. At 60 Hz, each has 16.7 ms; a 20-second film is 1,200 frames.
Primer: The GPU, and Why Only One Part May Touch It
Top: what a GPU is. Below, a writer is any agent, plug-in or view that sends DeepBuild something to draw.
Primer: Documents Can Be Checked; Pixels Can’t
So writers send DeepBuild documents, not pixels. Why: the same Q3 chart kept two ways, asked five questions.
The Canvas Core, Taken Apart: Five Pieces
The canvas core, opened one level down. Each box is a section of this part; the arrow is where it starts.
Four Ways an Agent Could Make a Picture
Four ways an agent could hand DeepBuild a picture, each with its main strengths and weaknesses. The scores follow.
Making Visual Work: What We Compare, and Why
Before the scores on “Making Visual Work”: each row is one column of the next slide’s table, and why it matters.
Making Visual Work, Scored: Only Documents Check and Fix
Four ways an agent could make a picture, scored on the columns the previous slide explains.
deep_kinds, docs, engine words mapped to ours); engines stay test references.107 / 449A Document, by Example: The Q3 Chart as Data
Documents won; here is one. Left: what an agent sends. Right: what the canvas core draws. Yellow labels name parts.
Document
One picture’s data, checked whole before it shows.
Envelope
The whole picture: profile (chart, film…), title, size, look (style), seed, cost budget.
Item
Anything with an ID and a kind: a bar, a label, a light.
Stable ID
An item’s name for good: never reused, never a position.
Handle
A link to the record, so a number shows its source.
Items and Kinds: Every Item Follows Its Kind’s Rules
A kind is the rulebook for one sort of item. Watch the canvas core’s check use it on five things an agent writes.
IDs never point by position
An ID is never reused after a delete. Renaming changes the name, never the ID, and an item never changes kind in place.
Who may add kinds
Canvas modules (DeepBuild’s own built-in code) register kinds backed by code. A pack, a versioned add-on bundle, may add kinds built from a recipe that makes items: data, never code.
Kinds Have Versions, So Old Documents Still Open
Kinds change over time. A chart saved under bar@1 opens in a DeepBuild release that ships bar@2. Follow it, 1 to 5.
Pack kinds migrate as data
A pack’s migration is rename, set and drop. No pack code runs, and no ID ever changes.
A failed comparison names it
It names the kind, the item, the field and the first time that differs.
Only you bless a change
A release that draws an old document differently waits for your decision, once per cause.
Units and Axes: One Measure for Every Kind of Number
A kind gives every param a unit. These are the units: one per kind of quantity, the same in every document.
Literals carry units
"300 mm", "45deg" or "0.6s" are converted at check. A bare number takes the field’s declared unit.
Sizes by the frame
fw and fh are fractions of the frame at design size: "1/300fw" at 1920 px wide is 6.4 u. px keeps a hairline fixed on screen.
One transform order
Subtract the pivot, scale, shear, rotate, add the position, then apply the parent. Euler angles turn about X, then Y, then Z.
Files from other tools
A z-up file converts at import. Exports write each track’s own timescale, never flicks; output color is tagged sRGB.
A Patch Changes One Value, Found by Its Path
Claude changes Q3 from 48 to 52 in rev 7, the chart’s 7th version (revision). The canvas core applies it, 1 to 4.
# a path names a part that isn’t an item, such as trees#42How a Patch Lands: Copied, Checked, Then Recorded Once
The last slide’s patch, opened up: what the canvas core and the hub do with rev 7 → rev 8, step by step.
All or nothing
Every op runs on the copy first. If any op is refused, rev 7 stays and not one byte changes.
A stale base
A patch on base 7 that lands after rev 8 rebases if no ID it touches changed; on q3 it’s a conflict.
A crash between writes
The file is written first. If the hub dies before the row lands, rev 8 isn’t current after a restart.
Held by a fuzzer
A dry run matches its commit, a refusal changes no byte, a patch then its undo gives back rev 7’s hash.
Paths Point Inside a Document; Handles Point to the Record
The patch found q3 by its path. A path points inside one document; a handle reaches the record, if you may read it.
Paths stay home
A path never reaches another document. Only a handle does, and a handle names a record object or a document.
Dependencies in plain sight
An expression never holds a raw path: a driver names its variables and binds each one to a path.
Who may read it
An agent reads through its session’s credential, a plug-in through its grant. A reply returns a value only to a caller that may read it too.
Closed lists
Sections: items, controls, channels, markers, data, inputs, assemblies. Schemes: the fourteen above, and no others.
Revisions: Nothing Shows Before Its Check Passes
Every patch or whole new chart makes a revision. Top: four from Claude, as they arrive. Bottom: what you see.
deep_show sends, must list every ID it removesFive states: pending · current · last good · superseded · refusedAn old issue (a problem a check found) the last good revision already had comes back marked carried, and doesn’t blockYour note on an item stays open until a later revision changes it and passes its checks; a writer saying “fixed” closes nothingWriter Layers: Several Writers Share One Document
The Q3 chart with three writers: you, Claude and Codex. Each writes only its own layer. Read moments 1 to 4.
doc.patched event in the record, so an item’s history shows who made what, and a merge by stable ID never loses a writer’s change. “Layer” alone means only this: one writer’s layer.Order Keys: Two Writers Insert at Once, Nothing Collides
Writer layers join items by ID, and a map keeps no order. Where order matters, each item carries a key that sorts.
A key between neighbours
order is a fractional index, a base-62 string. A new key falls between the two around it, so nothing else moves.
Seeded, so it repeats
Jitter seeded from (writer, patch ID) keeps two inserts at once apart, and a replay gives the same keys. Ties break by ID.
What draws on top, in 2D
First the writer layer’s band, then the layer’s own order, then the item’s order key.
And in 3D
By depth. A document’s writer layers share one depth pass and one light, so their 3D items hide and shadow one another.
Every Frame Is a Pure Function of the Document and the Time
From document to motion: the canvas core computes each frame from the document and a time t. Reach 0:07 three ways.
Document input
Recorded on the document’s input track and replayed, like a figure’s throttle.
View setting
A setting the document declares, like a chart’s pan. Kept per viewer; pinned for replay checks.
Viewer input
Orbit, zoom and hover. Kept per viewer, never saved, and left out of replay checks.
Point and Ask: Click What Is Wrong; the Agent Gets Its Name
A frame is a function of its time, so pointing at 0:07 tells the agent exactly what you saw. Follow 1 to 4.
Your selection is yours
Session state: never saved in a document or the record, and no agent can set it. The highlight is an outline, never a fill.
How exactly it hit
id names items; geometry a place on one; region alone, as on a captured screen, can be asked about but never patched.
If the item is gone
Its handle comes back detached, with who removed it, and your ask-task stays open.
When it lands
R1 click to select; R2 point and ask everywhere; R6 the lease on the selected IDs, the preview and the options.
Notes and Suggestions: Feedback That Stays on the Item
A return card is the card an agent’s stop leaves you. On it, three ways to answer a picture without an editor.
Only you write a note
On a return card, or in the editor panel with your input’s serial. No agent or plug-in can write, edit or close one.
It travels as data
The writer gets {note, doc, item, rev, t, region, text} as one send-back item, never inside a prompt of yours.
Never an ask
A note never opens or answers an ask; a suggestion never notifies you. Neither counts in Needs you.
Put back, honestly
An item another writer changed since is left out (undo_conflict), one under a live lease too (lease_held), each listed.
When it lands
Notes on a return card in R2; in the editor panel in R6. Put back acts on each document the turn changed.
The Canvas Reads the Record: Views Built From Events
Not every document comes from an agent: the app’s session line is rebuilt from the hub’s record, as of any moment.
record_viewStatus colors come only from a verdict, a run or an askTimeline From the Record: A Claim’s Film Builds Itself
Views come from events. So does a claim’s film: half an hour on issue #42 becomes 20 seconds, nothing reordered.
The agent writes little
Only event shots, the title and the narration script. Keys and markers come from the events.
Compress, never reorder
Events within 2 s merge; fit_to rescales gaps, never the order of what happened.
Captions set the pace
A line too long for its beat lengthens the film, or the film audit fails it.
The same builder, live
It appends as events arrive, so a session’s line is drawn the same way. It lands in R1.
Salience: Show About Nine, Fold the Rest Into a Count
A level of the Map can hold dozens of parts. Salience ranks them by what the record says and shows only the top few.
Rank by facts, no model
Needs you, sent back, failing, lacks proof, touched by this work, changed since you last looked, then priority. Ties by ID.
It holds still
The set changes when the level opens, or when a needs-you or a verdict changes. Other arrivals wait as “N new”.
About nine
Fewer if nine won’t fit at the minimum readable size. Ranks also set each item’s level of detail and label priority.
Where you meet it
Levels of views such as the Map, and each return card’s turn view: at most nine parts, files only as evidence. R1.
One Document Language: A Chart Grows Into a Film
DeepBuild has one document language. The same items take three profiles; a profile picks the sections and checks.
From Words to a Film (1 of 4): One Sentence, One Recipe
The chart grew into a film; now a whole film from one sentence: the 20-second explainer of the receipt bug, 1 to 3.
explain@1
Ten film recipes. Each turns a short cue list into shots, items, camera moves and sound cues, at check.
under 20 ms, the largestCue
One row of the film: when, which verb (write, fade_in, indicate), which words, which data.
{at: 1.2 s, kind: fade_in, …}Grammar as checks
One entrance at a time, text still once landed, exits faster than entrances, a section at most 8 s. A cue that breaks one is refused, by name.
refused, naming the ruleFilm brief
The plan fixed before work: goal, moments, reading holds, cue list. It becomes the checks; the working agent can’t change it.
a definition of doneFrom Words to a Film (2 of 4): Each Line, and What It Shows
Left: the film’s document. Right: its frame at 0:07; each numbered line leads to the part of the picture it makes.
From Words to a Film (3 of 4): Three Checks Before It Plays
Three checks the film runs before it plays. Left to right: where text sits, where numbers come from, how long text holds.
From Words to a Film (4 of 4): One Clock, 480 Frames, One MP4
Top: the film’s tracks on one clock. Middle: the frames that clock asks for. Bottom: what happens to each frame.
Virtual clock
Export draws frame k at exactly k ÷ 24 s, however fast the Mac is, so the file equals what you scrubbed.
frame 168 = 0:07.000Stays on the GPU
Hashed where it’s drawn: 32 bytes come back, not the frame’s 8.3 MB. A held frame is drawn and hashed once.
BLAKE3, before encodingAll or nothing
A failure at any frame stops the export, names the frame, and leaves no half-written file.
no partial MP4Receipt
Size, frame rate, duration, every frame’s hash, loudness and captions, kept with the file.
target: 2× real time or fasterChanging a Film: Say It, Point at It, or Fine-Tune It
You change a film the way you made it: in words. Or point at one item, or fine-tune it by hand.
Style is data
A look is an asset the film names, so “warmer” swaps one line. The numbers and checks underneath stay the same.
The camera is data too
A camera move is a shot: it goes a set amount, then lands. Slower, closer or a different angle is one value.
Nothing is lost
Every change is a patch in the record, so it can be undone, and the agent sees what you changed by hand.
Words That Mean One Thing Here
One language for every picture needs one meaning per word. These pairs are the ones newcomers mix up most.
One writer’s own layer of a document, and nothing else.
never: a graph’s rank, a collision group, a proof
A clip is animation that drives slots. A strip is media placed on a track.
never: a clip of video
A mask clips by shape, alpha or luma. A matte’s coverage comes from another item’s pixels, each frame.
A shot is a film segment with its camera move. A scene is a whole 2D or 3D document.
A line in the record; a baked contact, word or beat; a checked instant in a film.
One physics, logic or match step. Stages is the control that steps through states.
a slider’s move per key is its increment
A snapshot is a rendered image. A checkpoint is saved simulation state.
What you selected, as session state. Named parts are a builder’s top, side and rim.
Generates items; a set of items by list or rule; a container with a transform.
The time unit, 1/705,600,000 s, kept as a whole number.
never: tick
Why it matters
Fields, issues and tool replies use these words exactly, so a code like not_your_layer means one thing.
Where the list lives
The canvas reference’s first table: about 170 words, each with what it means, what never to call it, and why.
When words collide
Where an outside tool uses a word differently, its meaning here wins inside DeepBuild’s documents.
Inside the Canvas (1 of 2): Five Writers, One Compositor
Now the part that draws documents: the canvas core. Five kinds of writer send it data; it stacks them in order.
Compositor
What the canvas core is: the part that combines every writer’s layer into one picture, in a fixed order.
Band
A layer’s place in that order, set by what sort of writer it is, never by the writer.
Identity
A writer is known by its connection, never by what a message claims.
In a window
Nested in the app’s window: other apps can cover it, or capture it with permission.
Inside the Canvas (2 of 2): Take In, Draw, Guard
The canvas core’s nine jobs, in three groups. Follow Claude’s Q3 patch; after the scores, a frame step by step.
Who Draws the Pixels: What We Compare, and Why
Before the scores on “Who Draws the Pixels”: each row is one column of the next slide’s table, and why it matters.
Who Draws the Pixels, Scored: One Trusted Compositor
Three ways a canvas can be shared by many writers, scored on the columns the previous slide explains.
A Frame, and the Budget for Drawing One
Back to frames (slide 101), now with deadlines. At 120 Hz: pictures, ticks, and the canvas core’s share.
Frame
One still picture, as in the rendering primer. Here each one gets a deadline.
120 a second at 120 HzVsync
The tick at which the display takes the next frame. A frame not ready by then waits a whole tick: a stutter.
every 8.33 ms at 120 HzFrame budget
How much of one frame a job may spend. The canvas gets a small slice so the rest of the app stays smooth.
canvas: under 2 ms of 8.33UI thread
The one thread that takes your clicks and keys and lays out the app. If it waits, the whole app freezes.
never waits for the GPUDamage: Redraw What Changed, and Nothing When Still
How the core draws nothing when still: ten ticks, q3 changes at tick 5. Top: redraw all. Bottom: only the change.
Damage
The part of a picture that changed since the last frame. Only that part needs new work.
q3: 48 → 52Still view
Nothing changed, so nothing is drawn. The display link, the vsync timer, stops; the last picture stays up.
target: 0 frames, 0 wakeupsWhy it matters
The canvas is open all day on the Mac your agents are using. Idle redraws would cost that machine.
every kind of view: 0 when stillHow it is tracked
By item, then by layer, never by pixel. Step 7, a few slides on, shows how.
item, then layerOne Frame in 13 Steps, Grouped Into Four Stages
The whole path one change takes through the canvas core: q3: 48 → 52, from Claude Code to your screen.
Writer
Anyone who sends the canvas something to draw: an agent, a plug-in, the app’s own views, you, or the record.
Claude Code, writing the Q3 chartRevision and patch
A revision is a whole new version of a document. A patch changes a few values in one.
patch: items/q3 = 52Document session
One document in one place on screen, for one writer. In these steps, “session” means this.
Q3 chart · its panel · Claude CodeCompositor
The trusted part of DeepBuild’s app that draws every writer’s layer and stacks them in the window.
the canvas coreSteps 1 and 2: Who Sent It, and Is It Too Much?
Two writers send to the canvas core at once: Claude Code one patch, a plug-in a flood. Read each row left to right.
Who is writing
Read from the connection: you, the app’s shell, the record, an agent or a plug-in. A message can’t name itself.
writer: "you" → ignoredQuota
Each writer has its own: documents, items, message size, patches per second, GPU memory. It can’t share or raise it.
one quota per writerAdmission
Size and rate are checked first. A flood is rate-limited, then coalesced, then frozen.
never delays another writerA broken writer
A protocol error closes only that connection. Its documents freeze at their last good revision, with a badge.
the others keep drawingSteps 3 and 4: Checked to One Side, Then Held as Pending
Two revisions arrive. Top: a good patch passes and waits. Bottom: a bad one is refused. Right: the document session.
Check
Runs on another thread, so a big document can’t stall the app. Problems come back as data, with fixes.
issues, not a crashPending
A checked revision waiting for the next latch. One revision is in flight per document; the newest wins.
pending: rev 8Last good
What stays on screen when a revision is refused. Nothing unchecked is ever shown.
rev 9 refused → rev 7 staysHidden
A hidden document session is neither evaluated nor called back: it costs nothing until it shows again.
state: hiddenStep 5: The Latch Takes the Newest Revision Before Vsync
One frame, zoomed in. Three checked revisions reach the core at different times; the latch takes only the newest.
Latch
The moment each session takes its newest checked revision: vsync minus a lead, which leaves time to draw.
latch = vsync − leadNever mid-frame
A revision applies only at the latch, so one frame never mixes two revisions.
q3 is 48 or 52, never bothNewest wins
In-between revisions are skipped and their writers hear superseded_by. A coalesce key keeps only the latest value.
rev 8, 9 → superseded_by rev 10Budget
A patch shows within 1 frame of the latch.
1 frameStep 6: Compute the Picture for the Moment It Will Show
Left: the only reasons the canvas draws at all. Right: a landing rocket, computed for the moment the frame is seen.
frame(t)
As on slide 118: the document at one time t, with inputs up to t and the view.
same t, same framePredicted presentation time
The picture is computed for when you will see it, so a moving thing lands where it should.
not “now”, but when it’s seenPaced per display
Each window follows its own display. Inactive windows cap at 30 Hz, a hot Mac at 60, a hidden window at 0.
caps: 30 · 60 · 0 HzHidden costs nothing
A hidden session is never evaluated. Wakeups are counted and reported, so idle work shows.
0 frames while hiddenHow the Frame Clock Decides: Arm, Latch, Draw, Sleep
Step 6’s clock across a few seconds of one window: the rocket landing beside the Q3 chart. Values illustrative.
Step 7: A Change Marks Only the Kinds of Thing It Touched
A change is marked with the class of thing it touched, its dirty class (yellow dot). Right: the work that follows.
Epoch
A counter per item and per kind of change. Each step remembers the count it last ran at and reruns only if it moved.
nothing is cleared per frameBy item, then by layer
A changed item rebuilds only itself. An unchanged layer re-composites from its cache, kept after 3 still frames.
≤ 3 new layer caches per frameNever by pixel
The app redraws the whole window on every present, and a moving camera changes every pixel anyway.
pixels: no saving to findWhat it costs
CPU time grows with what changed, not with the size of the picture.
upload 32–64 B per changed itemContent Keys: The Same Inputs Always Reuse One Result
Two edit paths, one chart: epochs differ (left), the key doesn’t (middle), so cached work is reused (right).
Epoch says when
A counter that changed means: run this step again. It never decides what the result is.
when to recomputeKey says what
A fingerprint of everything a step read. Same content, by any edit history, gives the same key.
what can be reusedWhat a read adds
An array a step wrote enters by its writer’s key and step; only data from outside, such as a reading, by a hash of its values.
nothing read is left outProved, not assumed
Each canvas module’s fixtures prove a cached result equals a clean rebuild, and after a restart for what it keeps on disk.
cache = clean rebuildReuse or Rebuild: Each Step Asks Two Questions
The last slide’s rule as a decision every step makes. Three moments of the Q3 chart go through it.
Epochs are cheap
A counter per item and kind of change, 4 B each. Comparing two costs nothing.
Keys are exact
Equal keys always give byte-identical results; fixtures change each read alone to prove it.
Kept by key
An item’s result; a layer after 3 still frames; pipelines and tables shared across documents.
On disk (R6)
Read after a restart only if its key, its build and its sha256 all match; else rebuilt.
Steps 8 and 9: Drawn Off the UI Thread, Passed On by a Fence
Three lanes: the UI thread, a render worker (the core’s drawing thread) and the GPU. The window shows a slot.
GPU
A separate processor that colors millions of pixels at once. The CPU writes it a list of commands, which it runs later.
the 3D and effects layerEncode
Writing that command list, on the render worker. An unchanged batch replays last frame’s list instead.
worker: ≤ 4 ms CPU, ≤ 2 ms GPUFence
A signal the GPU raises when it finishes. Nothing sits and waits; the next step starts when it sees the signal.
never a CPU waitSlot
One of 2 or 3 images the GPU draws into. The window shows the newest ready one and holds it while it’s on screen.
free, rendering, ready, shownStep 10: Layers Stack in Bands, the Question Card Last
Left: the compositor’s six bands, bottom to top. Right: the same layers composed in the window, the card last.
Band from the writer
The core gives each layer its band from what sort of writer drew it. No layer picks its own.
agent → agent bandClipped to its panel
Every layer is cut to its panel. An agent’s layer is outlined with its name, so you know who drew it.
outline: Claude CodeClicks only where it draws
A layer catches input only where it visibly draws, never through its see-through pixels.
no invisible click trapsNothing above the card
No layer can sit above the shell or the card. Each layer costs one cut and one composite.
about 0.02 ms per quad (rectangle)Steps 11 and 12: The Window Shows It, Each Writer Hears
The window shows frame 1042; the core tells each writer what happened. Each row: its message, and what it means.
Presented
One message per frame that actually reached the screen, sent only while the writer is visible. About 40 bytes.
rev, frame, time, copied or notDiscarded
A frame that never reached the screen is reported as discarded. Nothing is reported as shown that wasn’t.
no false “shown”Credit
A writer may hold one update in flight. It sends the next after its message, so it can’t run ahead of the screen.
credit: 0 or 1The deep_show reply
An agent hears presented, or not presented with a reason (hidden, refused, timed out), within 2 s.
never blocked by a hidden panelStep 13: An Agent Sees What It Made, Never Your Screen
Two ways DeepBuild lets an agent see its work. Left: one document, rendered aside. Right: an app copy it drives.
deep_show, End to End: Who Carries Each Step
Steps 1 to 13 from outside the canvas core: the programs between Claude Code and your screen, and the reply.
Only Your Input Moves Focus or Answers the Card
Beyond the 13 steps, the compositor guards input. Left: a real input’s serial unlocks focus. Right: the card arms.
Cost: Estimated Before It Shows, Metered While It Runs
The compositor guards cost too. Left: a 3D castle scene, costed before it shows. Right: the costly layer steps down.
Budget class
Six: core view, data view, figure, work product, showpiece, export. A document may only tighten its caps.
figure: 2 ms GPU, 4 ms CPUMeter
Measures each writer’s layer every frame, from GPU timestamps, over a 120-frame ring.
per writer, per layerDegrade ladder
Steps down only the costly writer’s layer, and tells that writer why at every rung.
one writer never slows anotherFour More Jobs: Recovery, Hit Tests, Panels, Windows
Besides drawing frames, the compositor keeps writers alive and apart. One job per box; the picture shows the idea.
Liveness and recovery
A writer that stops answering freezes with a badge. A crashing step freezes only its session, at its last good revision. A lost GPU is rebuilt from documents; after a crash, documents and asks survive.
ping every 2 s · frozen after 5 sSpatial index
Each 2D view keeps a tree of item boxes, updated only where items changed. It answers what to draw and what you clicked. 3D clicks read an image of item IDs, so they land only where an item draws.
≤ 0.1 ms per move at 10,000 itemsPanel host
Panels that agents or plug-ins built run in a separate process and send trees of components, never pixels. They can’t reach the GPU, the network or a program, or draw over the card.
shipped panels: ≤ 4 ms per updateWindow placement
Only the app places windows, and a pop-out needs your input’s serial. Each window follows its own display; the question card opens on the display you last touched.
a pop-out in under 300 msThree Ways to Compute a Frame, and the One We Chose
Step 6 computed a frame at t. Three ways to do that, scored on what the canvas core must guarantee; yellow wins.
The Fixed Order of One Evaluation
Top: the core’s 11 phases per frame, the same path as steps 5 to 13. Below: one evaluation (step 6), in order.
Three Rules That Keep a Frame a Pure Function of Time
Three rules the core enforces, or a frame would depend on its past. An array: one value per item, such as position.
Why One Clock: Picture, Physics and Sound Tick Differently
The core’s frames depend on t, so t must be exact. Top: three clocks over 0.1 s. Bottom: per-frame rounding drifts.
The Flick: One Tick That Every Common Rate Divides
DeepBuild’s time unit. Left: the flick, and a time written in it. Right: flicks per frame or sample, by rate.
Seek Equals Play, and One Clock Leads at a Time
How the core keeps seek = play with physics: restore a checkpoint, then step. Bottom: which clock moves t.
Inside a Seek: Restore the Whole World, Step, Compare
The last slide’s seek to 0:07, opened up: what a checkpoint holds, the 60 steps, and the test that proves it.
Primer: Why a GPU? Two Million Pixels, One Small Job Each
The clock says which frame to draw. Six primers now show how a GPU draws it, starting with why a GPU at all.
pixels in one 1920 × 1080 frame
pixel runs a second at 60 frames a second
math operations a frame to light it once, at about 40 a pixel (an estimate)
the castle: 3024 × 2180, 6.6 million pixels, on an M3 Pro, CPU and GPU together
Primer: How a 3D Model Becomes Pixels, in Five Steps
Follow the rocket from numbers to a picture, 1 to 5. The GPU repeats steps 3 to 5 for every frame it draws.
Vertex
One corner point of a shape: where it is, which way the surface faces there, and where it reads its image.
position · normal · uv0Triangle
Three vertices. Every 3D surface, curved ones too, is drawn as many flat triangles.
indices: 0 1 2, 2 1 3, …Projection
The camera maps each 3D point to a screen point: farther things land smaller and nearer the middle.
the camera’s lens or flat viewDepth
A hidden image holding, per pixel, the distance of the nearest surface drawn so far. A farther one is dropped.
the depth targetPrimer: Mesh, Material, Texture: Shape, Surface, Picture
One idea each, with a tiny picture. These three words come back on every 3D slide that follows.
Mesh
Vertices plus the list of triangles. A builder makes one from a few numbers; it is built once, uploaded once, 32 B a vertex, at most 262,144 vertices a build.
positions · normals · uv0 · indicesMaterial
Base color, metallic and roughness, plus glass, glow and more. Values sit in a buffer, so changing one never recompiles. studio@1 names about 40 measured presets.
from: brushed_aluminiumTexture
An image in GPU memory that a surface reads at its uv0. DeepBuild’s patterns (wood, stone, roof tiles) are computed, so a built scene needs no image files; a glTF model brings its own.
pattern: wood · maps: base_colorPrimer: Light and Shadow: Facing the Sun, and What Blocks It
Two sums each lit pixel runs. Left: which way it faces the light. Right: whether something blocks it.
Normal, n
Which way the surface faces at a point. A builder computes it with every vertex.
A faces the sun; C faces awayLight direction, l
From the point toward the light. A sun is so far away that l is the same everywhere.
dot(n, l): 1 facing, 0 edge-onShadow map
The scene drawn from the light, keeping only distances. A point farther than the map says has something in front of it.
one depth pass per mapIn DeepBuild
Up to 32 lights shaded in a view; shadows from 1 sun (its map split near to far, up to 4 parts) and 2 spots. Soft shadows harden where things touch.
≤ 32 lit · 3 cast shadowsPrimer: A Shader Is One Small Program, Run Once per Pixel
What the GPU runs for each frame: shaders, one small program per pixel. Follow pixels A, B and C through one.
Shader
A small program the GPU runs once for every pixel, vertex or item. Each run sees only its own inputs.
one program, millions of runsInputs
What a run reads: its own position, plus values shared by the whole frame, such as the time.
p per pixel · t per frameOutput
What a run returns: here, one color for its own pixel.
A: 0.93 glow → flame yellowIn DeepBuild
Agents never send shader text. New GPU work comes as an operator, a graph the core checks and then turns into a shader.
operator → check → shaderPrimer: A Frame Is Drawn in Passes, Each Writing a Texture
A frame runs its shaders in passes. The rocket piece, pass by pass: each reads earlier images and writes a new one.
Texture
An image kept in GPU memory. A pass writes one, and later passes read it: color, depth, normals, object IDs.
color · depth · object_idRender pass
One sweep of drawing into a texture, called its target. A frame runs its passes in a fixed order.
shadows → sky → geometry → …Linear light
3D adds light up in plain physical values that can go far past white. Tone mapping turns them into screen colors.
shade linear, then tone-mapDrawn last
Status colors, text and overlays draw after every effect, unlit, so no effect or look can change them.
status colors after tone mappingTwo Draw Paths in One Window: GPUI and Our GPU Renderer
Who runs those passes? The app’s window has two draw paths: GPUI for the app and flat marks, our renderer for 3D.
GPUI
The Rust UI toolkit the app is built on, through gpui-kit. It draws the app with Metal on macOS.
R1: the app and 2D marksGPU layer
Our own renderer for what GPUI can’t draw. It draws into a GPU texture, never straight to the screen.
R2: 3D, effects, operatorswgpu
A Rust library that speaks each platform’s GPU interface: Metal, Vulkan, Direct3D 12 and WebGPU.
wgpu 30 on MetalHandoff
Getting the GPU layer’s texture into GPUI’s window, ideally by sharing memory, not copying.
an IOSurface on macOSWhich Path Draws a Layer: The Cheapest That Draws It Exactly
A writer layer stays with GPUI unless an item in it needs the GPU layer; then it all moves and pays a handoff.
Writer layer
Each writer’s own layer in a document. A layer changes path whole, never item by item.
Claude’s chart layerVello
A Rust 2D vector renderer. Its CPU version draws reference snapshots; its GPU version may take masks in R2.
Vello CPU · Vello GPUGolden
A stored reference frame that a check compares a new render against.
2D goldens: Vello CPUDisplay only
Shown on screen, but never read by a check.
a GPU effect in a 2D goldenThe GPU Layer: What We Compare, and Why
Before the scores on “The GPU Layer”: each row is one column of the next slide’s table, and why it matters.
The GPU Layer, Scored: Our Own Renderer on wgpu
Four ways to put 3D into the app, scored against what the canvas needs. Each row is one option.
How the Handoff Works: Three Slots, Two Fences
The chosen renderer draws into a texture; GPUI’s window must show it. One rocket frame, slot by slot.
Same memory
wgpu renders into the IOSurface that GPUI draws from, so nothing is copied.
Premultiplied
GPUI blends one × source plus (1 − source alpha) × what is below; alpha is never divided out.
No free slot?
That frame is skipped, never waited for; the last one stays up.
A lost GPU
Every module’s GPU resources are rebuilt from documents and assets, by hash.
Handing Over the Picture: A Tenth of a Frame, Not Four Fifths
Two ways to hand the GPU layer’s picture to GPUI’s window, timed in a spike (a short test build): share or copy.
paint_surface takes only 4:2:0 video frames with no alpha, so we added a BGRA path: 46 lines in its Metal renderer and a 7-line shader.get_io_surface() released the IOSurface once too often, so the code takes the raw pointer.A GPU Operator: New GPU Work, Written as Data
Where GPUI can’t draw, new GPU work comes as an operator. The rocket’s flame glow, as data: inputs, steps, an output.
Operator
New GPU work as a graph: inputs, steps, outputs. The core checks it and turns it into a shader.
rocket.flame_glowInput
The only way data gets in. Values live in a buffer, so moving strength from 1.0 to 1.4 never recompiles.
f32: a decimal · u32: a whole numberStep
One operation from the core’s fixed list, such as luminance or noise. No loops without a count, no code.
next: all six, built upOutput
What it hands back. A pass’s color is blended into the frame at its place; add only brightens.
vec4: four numbersBuilding the Flame Glow (1 of 2): Read, Measure, Keep
The flame glow, built one step at a time. Each panel: the step, the drawer it comes from, the pixels after it.
Textures
Steps that read an image: sample at a place, load one exact pixel, a size.
sample · load · sizeColor
Steps about color: brightness, a look’s named colors, blend modes, saturation.
luminance · role · blendMath
The same list drivers use on the CPU, so a step means the same on both.
smoothstep · mix · sin · dotEach run
Pixel P sits in the flame, Q in the sky. Every pixel runs the same steps on its own values.
values illustrativeBuilding the Flame Glow (2 of 2): Flicker, Scale, Color
Steps 4 to 6, then the output: the flicker, the strength, the color, and the frame with the glow added.
Seeded
Randomness from a hash of the seed and the place, never a stream, so every machine and every replay sees the same flicker.
hash · rand · noise · fbmArithmetic
add, sub, mul, div and the bit steps. Whole-number steps give the same bits on every GPU.
mul · add · and · shlValues
Constants, the inputs, explicit conversions, and putting numbers together or apart.
const · input · composeWhere t comes in
p mixes the pixel’s place with the input t, the frame’s own time: a scrub to 0:07 flickers as playing does.
never a clockWhat an Agent Can’t Write, and the Reason It Gets Back
Three lines an agent might reach for. Each is refused before the GPU sees it, with a code, a reason and a way that works.
The Whole Toolbox: Every Step Has a Drawer
The op table as drawers. Yellow: the flame glow’s steps. “exact”: same bits on every GPU, at least for integers.
steps a graph at most; 2,048 once every use is inlined
a repeat’s count at most; nested ≤ 2, ≤ 256 trips a run
texture reads a pixel (32 in showpiece and export); a read is a fetch
textures, 4 storage outputs, 1,048,576 elements a dispatch
Three Kinds of Operator: a Surface, a Picture, an Array
Same steps, three places to use them. Left: on a surface. Middle: on the whole frame. Right: on lists of numbers.
Material
Runs for the pixels of one surface, as the surface is shaded. Its vertex offset is capped, so the shape checks still read the true shape.
material.op: rocket.celPass
Runs once for every pixel of a whole image, at its place in a chain, and blends its color over what is there.
chain: effects | finishCompute
Runs once per element, up to 1,048,576 a dispatch, and fills arrays that later steps or an instancer read.
workgroups of 64 to 256A Material Operator, by Example: Toon Bands From the Sun
An agent wants a cel-shaded rocket. Left: the result. Middle: the steps for one pixel. Right: what stays the core’s job.
Light response
A material’s own `light` step, written with public steps. The core calls it for each light that shades the pixel.
default: core.light@1ALU
One basic math operation on the GPU, such as an add or a multiply. The usual way to count a shader’s cost.
cel ≈ 12 a light · default ≈ 40What it can’t do
See a light the policy cut, cast a shadow, change a light’s count or brightness. Its pixels pass the status guard.
estimates, until measuredFinals
Path-traced finals refuse a part with a light response, naming the part, since rays shade it differently.
R6, with composed graphsWhere Operators Run: Fixed Places in One Frame
One frame, left to right, the same order every time. Each kind of operator plugs in only at its own places.
No free edges
A pass reads only what was drawn earlier in this order, and says what it reads and writes.
declared reads and writesStill costs nothing
A compute operator whose inputs didn’t change keeps its last output, so a still view does no work.
kept by content keyFusion (R6)
Neighbouring pixel-by-pixel passes in one chain compile into one, so grain, vignette, tint and grade cost one pass; warm-up compiles each variant’s chain.
saves k − 1 passesLast word
After the status guard come only the upscale or history, then status colors and overlays.
nothing paints over statusWGSL, in Plain Words: One Glow, Written Two Ways
First what WGSL is. Then the shader primer’s glow written in it, beside the same glow as steps from the list.
Shader language
A small programming language for code that runs on the GPU, once per pixel or vertex. WGSL is WebGPU’s.
fn, let, return, vec4Line → steps
Each WGSL line maps onto steps from the public list: distance, smoothstep, sub, mul, compose.
same meaning, two spellingsWho writes it
Agents and packs write steps, or WGSL the core turns into steps. The GPU runs only WGSL the core wrote from checked steps.
never the agent’s textChecked, Then Compiled: Nine Gates Before the GPU
Two operators meet nine checks. One gets a cached pipeline; one is stopped, with the reason named.
naga
The checker inside wgpu. It reads every program the core writes and proves it well formed, with no optional GPU features turned on.
no 64-bit floats, no subgroupsRuntime checks
wgpu’s guards in the compiled program: an index out of range is clamped, no loop runs forever, no divide by zero crashes.
on by defaultPipeline
The compiled program plus its settings, ready to draw. Kept by the graph’s hash, so equal graphs share one.
≤ 32 a document sessionWarm-up
At check, every variant an item can reach in the film is compiled, so turning one on mid-film compiles nothing.
no stall on first useAn Agent’s WGSL: Each Line Becomes Steps, or Is Refused
An agent writes a ripple in WGSL. naga’s parser reads it, and each line becomes public steps or is refused by its number.
Lowered
A for loop with a fixed count (or an input with max ≤ 64) becomes repeat; if and else become select; switch up to 8 cases; calls are inlined.
discard → discard_ifRefused, by line
loop and while, its own globals or bindings, recursion, pointers past its locals, any builtin the list lacks. Nothing is guessed.
operator_source {line, construct}Keyed by its steps
WGSL and a hand-written graph that lower alike share one pipeline. deep_query shows the steps beside the source, line by line.
the text never reaches the GPUHow a Checked Operator Becomes a Pipeline
Steps written by hand or lowered from WGSL, once past the nine gates. The flame glow, from first show to reuse.
Who Brings Operators: the App, Packs and Agents
Three sources, one check, one way in. Left: shipped with the app. Middle: packs. Right: agents writing their own.
Group Passes: Effects on One Part of a Picture
The Q3 chart again. One group wraps the Q3 bar and its label, runs two passes on them alone, then blends back in.
Own target
The group’s children draw into an image of their own first, so the passes see only them.
children: [bar q3, label q3]Up to 8 passes
Run in order on that image: shipped, pack or agent operators, by name.
fx.levels@1, then blur28 blend modes
Then the result blends in at the group’s place in the draw order: over, screen, multiply and the rest.
blend: screenBackdrop
Run the passes on what is beneath the group instead, for a frosted panel or a blurred background.
a frosted panelSame Pixels on Every Mac? Three Determinism Classes
One operator, two Macs. Its determinism class says how alike its pixels come out, and where they may count.
Why decimals differ
WGSL lets a GPU flush tiny numbers to zero, ignore the sign of zero and assume no NaN or infinity; Metal’s fast default math adds more.
same program, other bitsExact allows
Whole-number and true/false steps, select on them, bit casts, whole-number loads, order-free atomics whose result isn’t read. No f32 step.
integers travel as bitsFingerprint
A same-machine result carries the GPU and core count, OS build, wgpu and naga versions. A golden hash from another reads INCONCLUSIVE.
golden: a hash kept to compareComputed, not claimed
The check computes each operator’s class from its steps. It may declare a weaker class, never a stronger one.
determinism: computedThe Status Guard: An Effect Can’t Paint a Verdict Color
The checkout film from the explainer. Left: a glow too close to FAIL’s red. Middle: the guard’s test. Right: the order.
OKLab
A way to measure color so that equal distances look equally different to people. The look sets how close to a status color is too close.
status.min_distance = 0.10Can’t reach status
Operators run before status colors, can’t read that layer and can’t write to a slot a status binding owns.
drawn last, unlitAlways on
No document, look or operator can turn the guard off where status can show. Other documents run none.
where status can showCost
One full-screen pass of about 30 ALU a touched pixel (estimate), skipped when no operator drew.
R2 with the GPU layerInside the Status Guard: Four Pixels, One Rule
The last slide’s guard, one pixel at a time: which pixels it reads, the test it runs, what it never touches.
An Operator’s Cost: Declared, Estimated, Then Metered
One number, checked three times. Top: the three gates. Bottom: the flame glow’s cost against its class.
Same verdict anywhere
Step weights come from tiny timing tests on the reference Mac, an M3 Pro, with its fingerprint, so a refusal is the same on any machine.
micro-benchmarkscost_understated
The estimate beats the declaration by more than 25%: refused before it runs, with both numbers.
declare honestlyOver the class
The declared costs of a document’s operators add up; over its class, refused, naming the top three.
* proposalsWords
scale: the share of full size a pass draws at. overdraw: how many times a pixel is drawn over.
half → 0.25 of the pixelsOperator Budgets: Each Class Gets a Share of Its Frame
What packs and agents may add, by kind of view. Column meanings first; the yellow row is the rocket’s.
| Budget class | Kinds packs and agents may add | Operator GPU time | Pass resolution | Compute elements | Operator storage |
|---|---|---|---|---|---|
| core view | none: shipped only | 0.2 ms* | n/a | n/a | 8 MB* |
| data view | pass, compute | 0.5 ms* | half | 1,048,576 | 64 MB* |
| figure | material, pass, compute | 1 ms* | half | 262,144* | 32 MB* |
| work product | material, pass, compute | 1 ms* | half | 262,144* | 64 MB* |
| showpiece | all three kinds | 4 ms at full screen* | full | 1,048,576 | 128 MB* |
| export | all three kinds | no frame cap | full | 1,048,576 | 128 MB* |
Frame History: The Live View’s Only Memory, Rebuilt on a Jump
Operators add GPU work; light is DeepBuild’s own. First, its one memory: the live 3D view’s window of recent frames.
Window
A fixed number of the view’s own recent frames, on a grid at its frame cap. Nothing older reaches a frame.
8 by default, 2 to 16Moved to t
Each older frame is moved to t through poses worked out at both times, then dropped where uncovered or changing.
depth, clamp, reactive maskUpscale
It can also render smaller and rebuild full size from the window’s jittered frames.
render scale 0.67 by defaultCost
About 12 B a pixel per window frame: about 90 MB for 8 frames at 1080p, at 0.67 (estimate).
work product and showpiece onlyRay-Traced Light, Where the GPU Has Rays
The GPU layer traces rays from each pixel for shadows, reflections and bounce light, if the GPU’s ray class allows.
From Light to Screen Colors: Bloom, Tone Mapping, HDR
The GPU layer adds light up in values far past white; the finish turns them into screen colors, in this order.
Light Inside Things, and Path-Traced Finals
Fog, skin and hair need light that travels inside matter. Film finals can be path traced: many rays a pixel, offline.
One Renderer on Every Platform: Seams and Backends
So far, macOS. Slide 61’s seams, for the renderer: one interface each, one backend per platform.
module_missing, never a quiet switch to one that changes results. No document names a platform.196 / 449Twenty-Four Canvas Modules in Six Families
The modules grouped by what they make. Each family is a section ahead; the arrow is where it starts.
The Building Blocks an Agent Writes With
From how the canvas draws to what agents write: one explainer frame in blocks. The next five slides open them.
A Q3 Chart, Piece by Piece: Marks, Scales, Bound Values
Group 1, marks and data: the Q3 chart of slide 108 as an agent writes it (left) and the canvas draws it (right).
Many rows, one item
A mark set draws one mark per row of its typed columns: 100,000 rows map in under 1 ms and draw as one batch.
Rules a chart keeps
Bars start at zero; a log scale refuses values ≤ 0; color-only categories stay apart for color-blind viewers.
Generated, not drawn
A scale maps values to positions or colors. Ticks fall on 1, 2 and 5 × 10k; axes and legends come from scales.
Live numbers
A bound value shows its source and as-of time. Past its freshness it grays out and shows its age.
Data Over Time: Bars That Glide, Lines That Reveal
A mark set holds the rows. When rows share a week or a year, the chart plays from one period to the next as time runs.
Periods
Rows that share a value of one column, such as a week, form a period. Between two, each key mixes from the one before to the one after.
Standing
Each period’s rows are ranked at check, ties by key, then mixed like any value, so bars glide past each other.
Reveal and emphasis
A reveal draws rows up to a point, its head carrying the value. Emphasis dims the rows it doesn’t name to 0.3.
Honest in between
A key missing from a period enters or leaves at opacity 0; a mixed number shows no more precision than its source.
Diagrams: Graphs That Remember, Paths That Reshape
Group 2, diagrams: the repo map gains a node and the rest stays put; salience folds the least urgent into a count.
Route
Edges route around labels and boxes; in a layered layout they get slots between ranks.
Label
Labels move aside, fold to a dot or hide, by priority, and stay reachable by keyboard.
Sheet
Cells at exact pixels, such as a taste call’s options. A click preselects; only the question card answers.
Formula
SVG from the typeset job (LaTeX or Typst). Its source text is kept as the accessible name.
A Sheet: Options Side by Side; Only the Card Answers
Diagrams show structure. A sheet shows choices: here a taste call’s two layouts, side by side, ready for your call.
Exact pixels
Each cell renders once at its exact device size, never scaled, and is cached; then one quad a frame.
Ways to look
A cell can show its option plain, in mono, reversed, blurred or mirrored, with highlights beside it.
Near twins drop
Two candidates under ΔE 0.1 apart at the 90th percentile of pixels count as one; the later is dropped and named.
Other sheets
A contact sheet of times, a variant sheet; in R6 a rig’s model sheet and a moment strip around a moment.
Formulas and Code: Written Term by Term, Quoted Exactly
Diagrams also hold formulas and code. Each keeps its parts by name, and a quote must match its source exactly.
Nothing typesets in the core
Formulas arrive as SVG, from the typeset job (pinned Typst and mitex) or the agent’s own renderer.
Terms keep their ids
So a step’s match morph moves the terms two lines share into their new places, and the rest fade.
Code takes the look’s roles
Tokens come from the agent’s own highlighter; lines number; a highlight dims the rest to 40%.
Quoted digits aren’t numbers
A quote’s digits are quotation, which honest numbers lists but never counts. A terminal recording plays in a cell grid.
Motion Without Code: Keys, Drivers, Constraints, Cues
Group 3, motion: the agent writes five seconds as a cue list (left); the check compiles it into keys (right).
Channel and key
A channel is a property that changes over time; a key sets its value at one time. Each segment moves by hold, linear, Bézier, an ease or a spring.
Driver
An expression over time, inputs and other values. At most 64 ops, no loops, no clock; a fallback for a divide by zero.
Constraint
A rule that places an item from others: child of, follow a path, look at, two-bone reach, keep a distance. Nothing iterates; a cycle is refused.
Cue list
Plays and waits in order. Any pack may add a verb, once it passes the verb tests (the cue kit).
Shots: Each Camera Move Goes a Set Amount, Then Lands
Cues time the motion; shots cut the film. Each shot names one camera move, sized by a default that reads well.
Moves with sizes
Push and pull 15% of the distance, pan 15°, orbit 30°, slam from 1.7×; also log zoom, follow a path, follow forward.
Framing, solved once
From the kept items’ bounds over the whole shot, so parts that fly apart stay in frame at every instant.
Cut or glide
A shot joins by a cut, or glides in over 0.8 s from the pose shown; a stage’s shot glides by default.
Reduced motion
A move cuts to its final framing at its midpoint with a 200 ms dissolve, unless marked essential; shake and slam drop.
Transitions: Joins Between Shots That Land on the Beat
Shots meet at a transition. Here a wipe joins two shots of the explainer, timed so its reveal falls on a beat.
Kinds
Cut, cross-fade, dip, wipe, push, iris, zoom-through, match morph, text diff, or a pack’s operator such as a page turn.
Both sides live
Each side evaluates at its own local time, draws offscreen, then blends: about twice a frame’s cost inside the window.
What it may not hold
A reading hold or a checked moment; it never hides a cut a check needs. At most two strips overlap on a track.
Reduced motion
Anything but a cut, a cross-fade or a dip becomes a cross-fade of the same span. Cut lands in R1; the rest in R6.
Mattes, Animated Type and Counters
Keys move items; three more kinds move or reveal type. Each is still computed from the time alone.
Matte
Coverage from another item’s evaluated pixels, frame by frame, by alpha or luma. It applies before status colors and never hides one.
Text animator
Up to four selectors (range, noise, field) over graphemes, words or lines. Text shapes only when it changes; per frame, glyphs just move.
Counter (R1)
A bound value or a driver, formatted as it changes, in tabular figures. A ticking counter never counts toward a reading hold.
Looks, Cameras and Overlays: Style That Never Touches Data
Group 4, style and view: the same curve and dot in the four looks that ship first. Only the look changed.
A look is one asset
Four ship first. Then whiteboard, blueprint, shadow play, pixel, comic, ink map, flat motion graphics, picture book and isometric 2.5D, each proven by a test film.
Camera
Shots, framing that keeps the subject clear of the overlay, a focus pull, and a loop that yields to you and eases back.
Overlay
Anchored type and controls in safe areas. A callout’s leader stays on its part as things move. It never mimics the app or the question card.
Controls: A Figure You Play With Writes One Input Track
Looks style a picture; controls let you play with it. Each gesture becomes one entry on one input track.
Three classes
Document: on the track, replayed, in goldens. View: a setting kept per viewer, pinned for goldens. Viewer: orbit, zoom, hover.
Kinds
Slider, toggle, choice, stages, transport, drag along, turn, press, text, hover, scroll; for games, point and actions.
A quiz with no code
A choice reads as its option’s number, so a driver can check an answer and count a score. A hotspot click picks an option.
Your hand only
No entry without your gesture, and no control answers an ask. A tour plays while you’re idle and yields to your first gesture.
Present Mode: Stages Hold While the Music Plays On
Controls let a viewer play; present mode lets you show a piece to a room, stepping it stage by stage.
Step and branch
→, Space or a remote advance; ← goes back on the path taken. A stage can wait for a choice and go on where it says.
Each step is an entry
Advances, backs, jumps and blanks go on the input track, so seeking equals playing. Paths only go forward, 64 at most.
Holds keep the beat
With a tempo map a hold lasts whole bars; beds marked to play on run through. A stage may loop a span while it holds.
Out of the room
An export takes one path; a PDF handout has a page per stage, with its settled frame.
Recipes and Builders: Agents Start From Strong Defaults
Last, recipes: rather than write every block, an agent names a recipe. One item and four inputs make a data story.
piece@1 pack
Twelve piece recipes: a product reveal, a physics lab, a walkthrough, a data story, a film of an agent’s change …
explain@1 pack
Film recipes written as a cue list: a proof, a chart’s story, an evidence board, kinetic type on the beat.
studio@1 pack
Lighting rigs, about 40 measured materials, looks and lenses, so 3D needs no tuning by hand.
Builders
Pure functions from numbers to 3D parts (slab, lathe, extrude, tube, ball …) with named parts and true shapes.
The Editor Panel (R6): Fine-Tune What an Agent Made
Agents start from recipes. When one thing needs your hand, the editor panel shows the document’s timeline and fields.
What it shows
Shots, markers and channels with their keys on the one clock; the selected item’s fields from its kind’s schema, with units and ranges.
Snapping, on
To frames, beats, markers, shot edges and other keys. A time written relative to a marker keeps its offset when the marker moves.
Read-only, with the reason
A derived item (with Break out), a generated marker, a baked channel, a view of the record, or an item under another’s live lease.
Same limits as agents
Outside a soft range warns; outside a hard range is refused, out_of_range. The playhead is session state.
One Gesture, One Patch: The Editor Writes as You
Every change in the editor is a patch, like an agent’s. Follow one drag, 1 to 5, from your trackpad to Claude.
Not your hand, no commit
A panel script, a timer, an agent’s computer use or a replica’s synthetic input has no serial: gesture_required.
The cart becomes yours
Changing an item an agent made takes it into your layer, unless that agent’s live lease covers it.
Undo by writer
Undo sends your last patch’s inverse as your next patch, so it removes your change and nothing of Claude’s.
Growing the Canvas Without Growing Its Core
Who may add new blocks? Five rings, from DeepBuild’s core out; the right column says who writes each ring.
A Canvas Module: One Crate, One Manifest, One Register Call
The modules ring up close: each module is one Rust crate (package). Left: its manifest; right: what it registers.
The 24 Canvas Modules and What Each Builds On
From one module to all 24 DeepBuild ships. A line joins each to what it builds on; the fill: its first release.
Packs are not modules
studio@1, explain@1, piece@1 and the rest are data. Each names the modules its kinds need.
Leave one out
Build sets core, r1, r2 and full each hold more modules; a document that needs a missing one gets module_missing.
When it lands
R1’s canvas code needn’t be split into modules yet. The registry and its seal land in R2.
No loops
No module may depend back on one that depends on it; the seal refuses a loop at startup.
Phases: One Fixed Order Every Module Plugs Into
How modules take turns: slide 155’s frame phases plus a check’s eight, owned by the core; modules plug in below.
Closed lists
The core owns both lists. No module adds, removes or reorders a phase.
Order from data
An operator is one unit of a module’s work. In a phase, one runs before another only if it writes what the other reads.
Ties by name
Module name, then operator name; items by depth, order key, then ID.
Never
Registration order, thread timing, a shared singleton, a hook, an observer or a message handler.
One Writer per Array: Modules Contribute, Never Overwrite
Slide 156’s rule: an array (one value per item, like its place) has one owner. Three modules place one caption.
Read set
Each operator lists every array it reads. The core builds its inputs from that list, so nothing else is reachable.
Same list, two more uses
The list is also the operator’s cache key and its change test, so a cache can’t miss a change.
Leave a module out
Its contribution is simply absent. The owner never names who contributes to it.
Never
Read what it didn’t declare, write another’s array, read a later phase, keep last frame’s value, read a clock.
The Seal: Every Module Checked Together at Startup
At startup the core checks all modules together: the seal. Three states, left to right; one failure stops the app.
Optional module missing
The seal leaves out only the operators that read it; a document that needs them is refused with module_missing.
Required module missing
The seal refuses. The app doesn’t start with that set of modules.
After the seal
Nothing in the sealed set changes until the next start. A pack’s entries resolve per document, outside it.
Registries: Every List Says Who May Add to It
Every canvas list is a registry others fill, closed with a reason, or open. One real list of each, then the rules.
The preflight
The local check before each release fails any list with no closure, and any registry missing its kit, its planted wrong entry or since, its first release.
Opening a closed list
Its owner declares a registry whose first entries are the old values, keeping their digests, so no document or golden changes.
The hub follows it too
Plug-in slots (deep.register…) obey the same rule; their fills are code that installs and replaces, never entries.
Inside the Seal: 24 Register Calls Become One Plan
Registries and the seal, run once at app start: what modules hand in, each check in order, what comes out.
Who May Add What to the Canvas
The rings as one table. Rows: what the canvas lets others add, with its list; a diamond: that author may add it.
| What others can add, and its list | Module | Pack | Plug-in | What every new entry must pass first |
|---|---|---|---|---|
| Item kinds made of code kind@1 | – | – | the module’s own fixtures | |
| Item kinds made of a recipe kind@1 | – | – | the kind kit, with a planted twin per rule | |
| Recipes, looks, materials, presets pack lists | – | – | the pack check, once per version | |
| Eases ease@1 | – | – | the core’s own, then packs’: 0 at 0, 1 at 1, monotone or a stated overshoot | |
| Cue verbs cue.kind@1 | – | – | the cue kit (motion declares the list) | |
| Graph layouts graph.layout@1 | – | the layout kit (graph fills its own five) | ||
| Constraint kinds constraint@1 | – | – | the constraint kit: no loops; they run every frame | |
| Control kinds control@1 | – | – | replay, a keyboard path, no agent input | |
| Export targets (MP4, glTF …) export.target@1 | – | – | a fidelity check whose reader isn’t the writer | |
| Check kinds check.kind.doc@1 | – | a planted twin per code; plug-ins via deep.registerCheck | ||
| Device classes device.class@1 | – | the class kit; a plug-in adds only its own ext. classes | ||
| Canvas modules themselves closed: ring | – | – | from DeepBuild’s repository only, each proved by its kit |
Growing the Canvas: What We Compare, and Why
Before the scores on “Growing the Canvas”: each row is one column of the next slide’s table, and why it matters.
Why Outside Code Never Compiles Into the Canvas
Four ways to let the canvas grow, scored on those columns. A seal can’t check outside code that registers itself.
How an Agent Extends the Canvas, Rung by Rung
What can an agent add itself? Four rungs, least new material to most, all checked; none draws its own pixels.
Every Check Returns Issues an Agent Can Act On
Every rung meets the same checks, which return issues as data. Follow one caption, 1 to 5; below, who owns which.
The core’s checks
validate, budget, frame time, layout, determinism, geometry audit, film audit, flicker, film layout, honest numbers, kind rules. They read only the core’s arrays.
Modules’ checks
record replay (record), input replay (input), export (export), physics.* and nav.reach (physics), logic.* (logic), net.* (net).
Plug-ins’ checks
Playtest, asset, rig and lip-sync checks through deep.registerCheck, reading evaluated data through deep.canvas.
Long lists
A reply inlines issues up to the read cap, errors first, and adds truncated with each code’s count; the whole list is evidence.
Inside One Check: From deep_show to the Issues It Returns
The last slide showed one issue. Here is its whole trip: who runs each step, and which rule decides what shows.
Film Layout, by Example: Boxes and Strokes, Never Pixels
One core check, film.layout: four problems found from glyph boxes and strokes, each with its patch.
Reads data, not pixels
Text boxes come from glyph outlines and strokes from the core’s flattened lines, so the answer is the same on every machine.
When it runs
At the end of every cue, hold and shot, and at the brief’s moments. Frames equal in data are checked once.
Whose thresholds
Overlap 5%, covered 30%, touch 4 u (1 u: a pixel at zoom 1) by default. A brief may tighten them; the working agent never sets them.
Honest Numbers: Every Number on Screen Has a Source
The honest-numbers check scans all text on screen: each number traces to a source or computation, or is a name.
Status Colors Come Only From a Verdict
Slide 188 for data: left, four ways a mark might take the fail color, and what the check does; right, the rules.
The legend appears whenever status shows
plus running, needs you, stale and idle, each with its own glyph
Drawn last, exact
Unlit, after tone mapping and effects. No mask, effect or other writer’s layer can cover it.
Never color alone
Each status mark carries its glyph or word: the mark at 3:1 contrast, the glyph or word at 4.5:1.
One verdict, one color
A document shown inside another takes its host’s status map, distance and legend.
Art may differ
A film played on its own may use any palette, but it still can’t draw a status color.
Render-Back: The Agent Sees, but a Picture Never Proves
Slide 149’s render-back, as an agent uses it. Left: what deep_show returns; right, views for finding a fault.
A picture never proves
Snapshots and modes help the agent see. A document check passes a claim only when the document is itself the deliverable.
Provenance
Every change is a doc.patched event. A by-writer lens shows who made what, and a merge never loses a writer’s change.
Second opinions
Blender, Unreal and Godot run locally from your installs as test oracles. Without one, that check is BLOCKED with one ask.
Inside Render-Back: How the Agent Gets Its Picture
What the last slide’s deep_show returns, step by step: who draws the snapshot, when it waits, how the agent sees it.
A 3D Scene Is Data: Shape, Material, Light, Camera
3D is a document too: one rocket on a pad. Each line the agent writes (left) adds a layer to what the app draws.
Shape
Made by a builder from a few settings: cube, sphere, cylinder, cone, torus, roofs, tubes; or loaded from a glTF file, the standard 3D file format.
cylinder · cone · glTFMaterial
How a surface meets light: base color, metal, roughness, glass, glow. Cloth, skin, car paint and water too.
metal · stone · glassLight
Point, sun, spot and area lights with color and power, plus sky and fog. Lamps are real lights, up to 32 a scene.
sun · spot · areaCamera
Where we look from: a lens or a flat view, depth of field, and moves such as push, orbit and follow.
push · orbit · followFrom Words to a 3D Scene (1 of 4): One Sentence, One Recipe
Now the rocket from one sentence: you ask, deep_kinds lists what to start from, and the agent picks, saying why.
deep_kinds
An MCP tool listing what a document can hold: kinds, recipes, packs, presets. Piece recipes first.
one example eachpiece@1
Twelve recipes for a whole piece: a subject and a few inputs give shots, narration and music.
product_reveal · flyover · …studio@1
Lighting rigs, about 40 measured materials, looks and lenses: names instead of numbers.
studio.sun_and_skyRecipe
Expands at check into ordinary items, so nothing is hidden: deep_query lists each one.
never per frameFrom Words to a 3D Scene (2 of 4): The Document, Line by Line
Left: the document the agent writes. Right: what each numbered line puts in the picture. It ends by calling deep_show.
From Words to a 3D Scene (3 of 4): One Miss, One Patch
Read left to right: what deep_show sends back, the one-value patch, and the snapshot before and after.
Loop checks
Each measures the scene and names a fix as patch ops: pull the camera back 1.4 m, raise exposure 0.7 EV.
scale · framing · exposure · …Same on any Mac?
Scale, framing and shading read the scene’s data, so they hold everywhere. Exposure and contrast read pixels, so they hold on this Mac only.
else INCONCLUSIVEPatch
One value at its path. The scene isn’t made again from scratch; only what the value touches rebuilds.
items/cam/params/…Not a picture’s word
A model looking at the snapshot gives only a reading or a taste ask, never a pass.
render.review: a readingFrom Words to a 3D Scene (4 of 4): What Each Line Becomes
Top: four kinds of line and what the app makes of each. Bottom: the passes that turn them into one frame.
Shapes From Builders, Changed by a Stack of Modifiers
Builders (slide 211) in 3D: a cube becomes a row of blocks that builds itself as modifiers run in order.
Builder
Turns a few settings into a mesh with named parts and texture coordinates: cube, sphere, cone, torus, roofs, tubes, or a surface from a formula.
cube · torus · surfaceModifier
Changes the mesh above it: array, mirror, subdivide, bevel, solidify, displace with seeded noise, deform along a curve, build. A doubtful order is flagged, never silently fixed.
bevel · array · buildRecipe
A versioned group with typed inputs and defaults that calls builders and modifiers, so a new kind of shape needs no new code.
inputs · defaults · stepsBuildings
Walls, doors and windows cut as holes, eight roof types, stairs from the rise. Switching the prototype house to cutaway rebuilt 10 of its 91 nodes.
wall · roof · stairMoving Without Simulating: Motion Computed From the Time
Four kinds of motion, no physics: the canvas computes each frame from the time alone, so a seek equals play.
Skinned clip
A character’s own glTF skin (a mesh bent by bones) and clips, sampled at the time. A walk can slow and stop on its mark; mouth shapes let a face speak a line.
up to 256 bonesParticles
Worked out fresh each frame from age, index and seed, never stepped. Bursts start from events; bounces only on planes the piece declares.
1,048,576 in a showpieceMesh sequence
An asset’s shape for each frame, played by the time. A flock shares one wingbeat; 100,000 walkers each play it at their own phase.
mesh.sequence@1Puppet rig
puppet@1: parts, held expressions, mouth shapes, two-bone reach. A new rig is shown to you once as a model sheet; rig checks catch pops and sliding feet.
puppet@1A Character Is a Rig, Shown Once as a Model Sheet
The puppet rig on the last slide, opened up: a character as data, approved once from its sheet, checked from then on.
Held drawings
Expressions and views are drawings: one shows until the next key, never a blend. Parts draw in the shot’s look.
Shown once
A new rig’s model sheet is one taste ask keyed by its hash. Until you answer, a shot that shows it is BLOCKED.
Anything that acts
An object with a face that acts, such as a mug that frowns, is a rig too, held to the same checks.
Never a copy
No living artist’s, studio’s or trademarked character. Caps of 64 parts and 8 chains are proposed.
Skinned Playback: A 3D Character Plays Its Own Clips
A drawn rig is one kind of character; the other is a 3D asset with its own skin. Both play from the time alone.
Its own skin
A licensed or generated glTF character’s skin and clips, sampled at t. At most 4 influences and 256 bones; a bone is item#bone.
Mixed, never stepped
Placements mix by weight in a fixed order; an add placement lets a wave ride on a walk; only limits it to bones.
Feet that don’t slide
Travel follows the clip’s own feet along a curve; a walk, a stop and a turn chain with no jump. A contacts check reports slides.
Faces and props
Morph targets take weights as channels, so a face speaks a line’s visemes. A file with no skin moves its parts rigidly: a lid opens.
Worlds Too Big to Draw Whole: Chunks and Voxels
When a world is too big to draw whole, the canvas splits it. Left: terrain chunks, finer near you. Right: voxels.
Chunk tree
A terrain, a huge mesh, a point cloud (PLY, PCD, LAS) or a 3D Tiles region, cut into chunks; each child is finer than its parent.
chunks@1Under a pixel
A view draws the coarsest chunks whose error would show smaller than a pixel. Live, the nearest load first within a byte budget.
Never coarser
Final frames, exports and checks wait for every chunk they need. One that is missing makes them BLOCKED, never drawn coarser.
BLOCKED, not blurryVoxels
3D pixels: a grid of palette colors from an asset or a game’s logic, meshed brick by brick on the CPU; only bricks a step changed are meshed again.
voxels@1 · 256³ from logicFrom Scene to Pixels: Passes, Live Extras, Final Frames
How the app draws a 3D scene, in the passes of slide 166. Bottom: live-only extras, and what checks use.
- Smoothing, upscaling and ray denoising keep a fixed window of recent frames; a jump draws that window again.
- HDR on XDR displays.
- Budgets bend: 256 MB of GPU memory a window; a big 3D view drops to 0.5 internal scale, then a 2-frame history.
- sRGB and no history: each frame stands on its own, at full scale.
- Light without history, or rays at many samples a frame.
- Path-traced finals render offline, each seeded by its own frame number, and replay exactly on one machine.
First Try, Then Checks: One-Shot Scenes and Machine Figures
An agent names presets; the canvas checks. Left: a one-shot scene fixed by one patch. Right: an audited machine.
studio@1
Lighting rigs, measured materials, looks and lens presets an agent names instead of numbers: Neutral for products, AgX for night and fire.
rig · look · lensLoop checks
Scale, framing, exposure, contrast, shading defects, overlaps, floating parts, missing assets, noise and budget, each naming its fix.
measured on a renderMachine figure
Explains an idea by building a working object: assemblies from 18 part kinds, eased take-apart, a card with a live readout.
about 4–5 ms a frameThe audit
Checks every part’s true shape. The 43-part dial gauge passes with zero failures; each failure names parts, check, time and fix.
JSON reportInteractive Pieces: On the Canvas, or in a Game Engine
From watching to playing: a bounded piece runs on the canvas; a whole game goes to an engine project.
Canvas piece
Interactive visual work and bounded games: rules, rooms and things that fit the arrays and bodies the piece declares, with saves.
physics · logic · netEngine project
A complete game goes to a pinned engine, Godot first. A first-party blueprint creates, builds, launches and drives it through journeys.
game project blueprintPlaytest
The check that needs live play. Bots play seeded runs; a run fails when stuck, short of a goal, trapped or over budget. Each run replays.
deep.registerCheckGenre kit
One genre’s tested core as libraries a piece links; the grid core comes first. pixel@1 draws tiles and sprites in at most 32 colors.
grid core · pixel@1Interactive Pieces, Taken Apart: Physics, Logic, Shared Play
Three canvas modules make a piece playable. Each splits into the parts the next slides explain.
Physics Primer: Fixed Steps Make a Replay Land the Same
Play needs physics: the physics module steps the rocket at a fixed rate, stamps each press, and keeps checkpoints.
What a Physics World Holds: Shapes, Bodies, Joints, Forces
The rocket as a world document an agent writes. Each yellow label is one kind of item; touchdown is an occurrence.
Shapes
Sphere, box, capsule, cylinder, convex, static mesh, height field and compound; segments and polygons in 2D.
box · capsule · convexBodies
Static, kinematic (follows a channel), dynamic, character or vehicle. None is created mid-run: declare it inactive, then wake it.
static · dynamicJoints and forces
Hinge, ball, slider, spring, rope, gear and more, with limits, motors and a break point; a break is an event. Wind, drag, buoyancy.
hinge · rope · windOccurrences
Events the world records: contact, sensor, break, rest and crossing, sorted per step and baked, so sounds, drivers and charts read them by time.
contact · breakHeroes, Cars and Paths: Character and Vehicle Bodies
Three game features from the physics module, none in the core: a hero, a car on sprung wheels, a path.
One capsule that the backend’s character controller moves, with a slope limit, a step height, snap to ground and a jump. Only its inputs, its controller and gravity move it.
A chassis on up to 8 ray-cast wheels with sprung suspension. Drive, steer and brake are held inputs; steering follows Ackermann’s rule; a wheel touching down writes an event.
An asset job bakes a graph from the level’s fixed shapes, and the piece’s own logic finds paths on it. nav.reach proves every goal can be reached.
One Physics Step, in Order, and How a Seek Lands on It
The bodies of the last slides, moving: the order inside one 1/120 s step, then how a frame and a seek (160) read it.
Physics Proves Itself: Hashes, Goldens, a Behavior Kit
The physics module proves it replays: play vs seek on one Mac, a golden across two, and a behavior kit.
Bake
Kept by the document, the input track and the backend’s version. It holds checkpoint hashes, events and outputs, so playback never re-simulates.
Golden
Hashes recorded on one machine and checked on another. A mismatch names the first step and field that differ.
same backend, two MacsBehavior kit
Fixtures with answers worked out on paper: free fall, a projectile’s range, a pendulum’s period, a slide, a jump. Any backend must pass.
tolerances are oursSoft body
Ropes, cloth, balloons and a jelly cube, each particle with a stable name. Heavier cloth and fluid bake offline and play back exactly.
soft@1Game Rules as Code: Logic in a WebAssembly Sandbox
Physics moves the rocket; its rules (burn fuel, landed or not) are logic, a small program. One step, in to out.
WebAssembly
A compact program format that runs the same in the app and in a browser. The agent builds it in its own repo; the app takes it by hash.
logic@1Reads only what it declares
Its controls’ entries, recorded readings, other arrays as earlier steps left them, and a seed from the document.
reads: […]Writes only its own arrays
Never checks, verdicts, the record, status colors or the question card. It never draws: the core draws what it writes.
writes: {…}Whole state saved
Memory and globals are its whole state, checkpointed like a world’s, so seeking equals playing, proved by full-state hashes.
checkpoint · bakeFuel: A Runaway Loop Stops at the Same Spot Everywhere
The sandbox module rewrites each program to count its work, so a runaway step traps at one spot everywhere.
Budgets
Per step by default: 1,000,000 fuel, 4 MiB of memory, 64 KiB of stack. A piece may raise them to 10,000,000, 64 MiB and 256 KiB.
budget: {fuel, memory, stack}One subset
WebAssembly 2.0 without vector instructions, one memory of fixed size, tables that never change, no imports. The app runs it in wasmtime, pinned.
sandbox@1Step ceiling
Heavy work such as an AI’s turn is split across steps. deep_kinds publishes how much fuel a step may use within a live frame.
logic.budgetReported
A trap is reported with its step, the inputs that step read, and where it stopped. A run that trapped can never pass.
logic.trapLogic and Physics on One Clock: Who Steps First
With fuel bounding each step, here is how a logic step meets physics on the clock, from one press of thrust.
Logic reads the past
Its read region holds the entries since its last step, arrays as earlier steps left them, and a seed, hash(doc seed, logic ID, k).
Physics reads the present
At its own step’s time it reads logic’s arrays and the inputs logic fired, so at one instant logic runs first.
A frame reads both
Logic’s arrays as the last step at or before t left them; poses mixed between two physics steps.
What Logic Gives a Game: Sounds, Saves, Turns, Libraries
Six things a game needs from its rules. Each is a small, checked addition to the logic module, shown in action.
Occurrences
A step can write events (a score, a hit, a door opening); sounds, bursts and clips play at their steps. A step past its cap traps instead of dropping one.
Saves
Stop and go on later. Written whole or not at all; each slot keeps its newest and the one before. A fix that keeps the layout keeps every save.
Turn clock
With clock: on_input, a step runs only when input arrives, so an idle turn-based game runs nothing and lets the app sleep.
Smooth drawing
A write marked linear is drawn blended between the last two steps, so a 10 Hz simulation still moves smoothly on screen.
Preview
On hover, a throwaway copy works out the path to a hex or a fight’s forecast. Never saved, sent, hashed or exported.
Libraries
Pinned libraries, such as a genre kit’s grid search, are linked in at check, only once their own tests pass. The running program still imports nothing.
Agent Code in a Piece: What We Compare, and Why
Before the scores on “Agent Code in a Piece”: each row is one column of the next slide’s table, and why it matters.
Agent Code in a Piece: Sandboxed WebAssembly at a Fixed Step (R6)
When a piece needs real rules (a game, a bot), what code may it hold?
Shared Play: Only Inputs Travel Between Players
Two players, in the app and a browser: the net module runs the whole game on each copy, and only presses travel.
Every copy runs everything
Same document, input track and modules, by hash, at one match step (60 Hz by default). Two to eight players.
net@1Only inputs travel
Each copy sends its player’s entries for each step; every copy orders them by step, player and seq, never by arrival. No state, no pixels.
about 32 B + 32 B an entryA relay that holds nothing
A relay only forwards messages. Copies meet through the one a piece declares; DeepBuild ships a small relay you run, and runs no service itself.
relay@1Join
Nothing opens until a person clicks Join on a prompt the app or player draws, naming the relay. No cookie, credential or anything about you.
A Late Input: Roll Back and Replay, or Wait in Lockstep
An input arrives late: the net module rolls back and replays (top, light pieces) or waits in lockstep (bottom).
Desync
Copies compare full-state hashes every 60 steps. A mismatch stops the match and names the first step and field. It is a defect, never retried away.
net.desyncFair rolls
After an attack is confirmed, every copy adds 64 secret random bits, committed before revealed, so nobody reads a roll ahead or picks it.
draw_afterCourtesy fog
Each copy may hide what its player can’t see, but every copy holds everything. The Join prompt says so in plain words.
match.meReplay
Every match keeps its merged input track, so it replays exactly and exports like any piece. An export never shows a predicted frame.
One Match Step on Every Copy: Send, Predict, Confirm
Under the rollback: what each copy sends every step, what it assumes until it hears, and when a step is final.
One message a step
Each copy sends one per match step, empty or not, and repeats any not yet confirmed; a receiver keeps the first copy.
By step, never by arrival
Entries go on every track by (step, player, seq), so every copy applies the same entries at the same steps.
Final once confirmed
A copy runs at most 8 steps past confirmed. Saves wait for it; a full-state hash every 60 confirmed steps.
Sound on the Picture’s Clock: Five Tracks, One Playhead
Sound runs on the picture’s clock: five tracks, one playhead (black line). When line 2 moves, its motion follows.
Track and strip
A strip places a sound, a video, an image or a job’s output on a track, with in and out points, fades and gain. Cuts fade over at least 5 ms, so no edit clicks.
strip · trackNarration sets the pace
A line can start a set gap after another; motion can anchor to a line’s start or end. Overlapping lines are refused.
anchor · gapCaptions, always on
Designed by the look and timed by a caption profile (reading-speed rules); burned into the frames, or carried as .srt and .vtt files.
.srt · .vttNever by surprise
Sound starts only after your gesture, with an indicator naming its owner, and a true-peak limiter caps the output.
device gateNarration, Music and Effects: Made by Jobs, Then Checked
Each sound is made once, offline, by a pinned job (a fixed tool version), kept by hash. Follow one narration line.
Export: One Canonical Render, Seven Ways Out
Out of the app: each export redraws the frames you scrubbed, offline on a virtual clock, for seven targets.
Virtual clock
Rendered offline: frame k is the frame at exactly start + k×Δ, so the file never depends on how fast the machine drew it.
Kept by hash
Each frame is hashed on the GPU, never read back, and each sample on the CPU. A held frame is drawn and hashed once, however long it holds.
frame_hashes · pcm_hashesDraft or delivery
A draft runs the frame guards only, stays in the app’s store, and can never be shared, attached or sent.
purpose: draftAn Export Proves Itself Before It Leaves the App
The export module’s five guards, left to right: any failure stops a delivery, names the frame, leaves no file.
glTF
Checked by the Khronos validator and a round trip. One file per engine profile: plain glTF, Unity, Unreal, Godot, Blender, Roblox.
asset.validateLottie
2D motion for the web. It lists what Lottie can’t hold instead of dropping it, and is read back by a pinned reference renderer.
export.fidelityPlayable page
Stages, choices and variants as rendered stills and clips. No network, no code from the document; up to 64 states and 256 transitions.
pageWeb player
The canvas core built for the browser, with physics and logic live. It won’t play until every file matches its hash.
<deep-player>Inside an Export: Who Draws, Who Encodes, Who Reads It Back
The five guards, by who runs them: the encoder never judges its own file. One frame of the explainer, 1 to 9.
Budget Classes: The Canvas Must Not Slow the Agents’ Mac
The caps the canvas holds each view to: slide 152’s six classes in full; next, how the meter holds them live. * proposal.
frames drawn while nothing moves, in every class
heap allocations a frame after warm-up
of GPU memory a window; a big 3D view first renders at half scale, then keeps 2 history frames
for a drag to show on screen; a patch within 1 frame of the latch; cold opens and edit loops are timed as readings
How the Meter Steps One Layer Down, Frame by Frame
Those caps, held live: the meter times each layer every frame; 30 slow frames in a row drop it one rung.
When the Canvas Counts as Done: Six Shorts, Made Twice
When is the canvas done? Six short films from briefs, made in 2D and again in 3D, must be easy to make and good.
1 · A look speedrun
one room through twelve looks in about 15 s
2 · A long scroll
a walker crossing six worlds, each edge on a downbeat
3 · A painting that stays alive
the sky drifts, lamps pulse, leaves sway
4 · Kinetic type on the beat
words that slam in at 120 BPM
5 · An evidence board
built from a claim’s record
6 · A 54-second explainer
one object throughout, and one chart
Each short must
An outside film gate, run locally on our exports, is a reading beside your yes, never a pass. First to ship polished: film recipes (explain@1), painterly looks (art@1) and examples.
The Done Bar, Continued: One Interactive Piece, Twelve Films
The rest of the bar: one interactive piece, through an interruption, seek, fork and reload (left); twelve films.
One frozen interactive brief, judged as one piece
Six to nine shots, one recurring subject, a rigged character, two choices and a slider, a camera move, a look change, an exploded view, narration and an impact.
60 s × 48,000 = 2,880,000 samples per channel
Any runner its proof needs that is missing leaves it BLOCKED, never PASS.
Twelve math and science films, each from a one-line brief
Each passes its brief, film.audit and film.layout within three rounds, and gets your yes on its final taste ask.
An Agent Makes a 30-Second Explainer (1 of 2): Checked First
All of Part 3 in one task, 1 to 6: recipes, a document, checks before anything shows; one fails, naming its fix.
An Agent Makes a 30-Second Explainer (2 of 2): Out the Door
Read 7 to 11: the checked film renders on the virtual clock, its narration is heard back, and you make one taste call.
Your Project as a Map: From Transit Lines to a 3D City
The canvas also draws DeepBuild’s own record: version 0’s flat Map (left) and, from R2, a 3D city (right).
A picture of the record
Parts by folder and route, proof by what each check covers, sessions by the files they touch, costs from bills. Nothing is drawn by hand.
Lenses
Proof, cost and moving work: sessions by repo, conflicts a trial (dry) merge found, who holds which lease, and the disk each session uses.
proof · cost · workBuildings by kind
Page: shopfront. Code: a glass tower as tall as its code. API: a tower with a gate. Data: a tank farm. Docs: a library. Machine: a server hall.
R2Or tiers
Instead of a city, parts and services as nodes on tiers of glass and stone, linked by conduits; a time slider replays the day.
How the Map Gets Its Data: Files, Hooks and Checks, No Model
The Map is built from the record, not drawn: four sources place checkout-web’s parts, sessions and proof.
Flying Into a Part, and Live Readings on the Map (R2)
Click a part and the Map’s camera flies in. Map layers from plug-ins add live rows, each citing a source.
What a part holds
Items, links, plain facts and this week’s changes. Each fact cites its file and line: tables from schemas, endpoints from routes.
repo.facts@1Map layers from plug-ins
A map layer returns rows anchored to names the map knows. A row that cites nothing that names it is refused.
map.layer@1Live traffic
An edge with a request-rate reading draws particles at that rate and greys when stale. No source, no traffic.
readingRead now, and notices
Read now re-reads each source through its own quota. A notice exists only because you asked for it.
deep.readNowThe Canvas by Release: What You See in R1, R2 and R6
Part 3 by release, left to right: each column is what a person using that release can actually see on the canvas.
Part 4: Trust
Under See, Steer and Make: can you trust an agent’s “done”? Done is fixed first, and only checks earn a verdict.
Trust, Taken Apart: The Done Gate and Its Defenses
Trust is the done gate, a hub extension, plus defenses around it. Each box is a section; the arrow is where it starts.
Who Writes What, for a New Feature
Four pieces are DeepBuild’s own code. Only the tests are new for each feature, and an agent writes them.
| Piece | Written by | When | New per feature? |
|---|---|---|---|
| The hook (deep-hook) | DeepBuild, in the app | installed once, at setup | No |
| The done gate, the judge | DeepBuild | ships with the app | No |
| The validity gate | DeepBuild | ships with the app | No |
| The browser runner and screen compare | DeepBuild | ships with the app | No |
| This feature’s tests | the drafting job: your own agent, headless | when the task starts, from your request | Yes |
| Your repo’s own tests and CI | you, already in the repo | before DeepBuild | No, reused if there |
| “Does it look right?” | you | at the end, if it’s taste | Yes, one tap |
What the drafting agent needs
Needs: your requestAn issue or a prompt. For a new feature, done comes from your words.
Uses, if thereThe repo as it is now, tests it can reuse, your usual proof bar from the wiki.
No history?Fine: it writes every test new from your request.
Too vague to test?“Make it nicer” becomes one early question, or a taste call at the end.
Written once
The hook and both gates are DeepBuild’s own code, the same for every task. Nobody writes them per feature.
Written per feature
Only the tests. An agent has to read your request to write them, so the drafting job does.
Decided by code
Once written and locked, the tests run as plain code. No agent judges a stop.
Issue #61 (1 of 7): You Point an Agent at It
One real path, filed to merged, with what you actually see at each step. It starts with an issue and three words.
GitHub · checkout-webillustrative
Keep the order total above the fold on phones
On a phone the total sits below the fold, so people scroll to find it. Screenshot attached.On a 390×844 screen the total is fully visible without scrollingNothing outside the checkout panel movesThe cart’s unit tests still passYour sessionillustrative
How DeepBuild knows
The prompt names #61. A branch named for it, or the agent running gh issue view 61, works too.
Nothing to set up
No command and no form: the prompt hook sees the issue and opens a task for it.
Done comes from here
The three checkboxes are what done means. Your words, not the agent’s plan.
Issue #61 (2 of 7): A Separate Run Writes the Tests First
At 10:00, beside the working agent, a headless run of your agent turns the three checkboxes into checks.
.deepbuild/ · the definition for #61illustrative
Tried once on the old code, a1b2c3
Locked. In Needs you: “Definition for #61 · decided for you” with an Overrule button.
Who wrote them
Your own agent, run headless by DeepBuild beside the working one. It saw the issue and its screenshot, the old code and your wiki, never the work.
Why it can’t cheat
The working agent can dispute a check with you, never edit it. Its hash is checked at every stop.
When you’re asked
Only if a criterion can’t become a check, such as “looks clean”. Here all three could.
Issue #61 (3 of 7): The First Stop Is Checked in Seconds
The agent says it’s done. Quick checks answer in the chat; the browser test starts only because the turn ended green.
Your session, 10:08illustrative
Issue #61 (4 of 7): The Journey Fails and Wakes the Agent
A minute later the browser test lands on 4d2a: the total moved up, but not enough. The agent hears it, not you.
Your session, 10:09, a new turn nobody typedillustrative
A fact, so it goes to the agent
902 > 844 is not a matter of taste. You aren’t asked anything.
It names where
The failing step, the measured box and the file behind it, from the evidence, with no model.
No message from you
Claude Code was idle, so a small waiter hook woke the same session with the failure.
Issue #61 (5 of 7): Facts Pass; the Look Is Your Call
At 10:12 the journey on snapshot 7be1 passes. Every fact is green, so one question goes to you: do you like it?
Needs you · on your phoneillustrative
Keep the new checkout layout on phones?
r1 total ends at 780 px, within 844r2 only the header and the total moved, both inside the panelr3 14 tests passKeepMove it10:31: you tap Keep, on your phone.
Code checked the facts
Where the total ends and what else moved are measured from the page, on both versions.
You judge the look
No model decides whether it looks right. The before and after reach you side by side, the change marked.
It doesn’t block
The card waited while you asked for the PR and its checks ran. Unanswered, Keep applies at its deadline.
Issue #61 (6 of 7): The PR Is Checked Merged With Main
At 10:13 you ask for the PR. Its last checks run merged with main; PASS lands once you make the call.
Your session, 10:13illustrative
GitHub · PR #63illustrative
Keep the order total above the fold on phones
Closes #61 · deepbuild/done ✓r1 journey: before and after, the change markedr2 compared with the base, step by stepr3 14 tests, in the full suiterelease checks on the merge with mainyour call: Keep, 10:31Merged, not just branched
Your repo’s release checks run on the PR merged with main, so it works where it lands.
Only PASS closes
Had anything been left, the PR would say “Part of #61” and list it.
The agent can’t fake it
Closing #61 by hand is refused while its definition hasn’t passed.
Issue #61 (7 of 7): One Card, and What Stays
You read one card with the evidence, not the agent’s summary. The checks it earned stay with the repo.
The return card · DeepBuild appillustrative
PASS 4/4 · Closes #61 · PR #63
total above the fold: journey, before and afternothing else moved: compared with the basethe cart’s tests: 14 passedrelease checks on main: greenYour call: Keep, 10:31 · 3 turns, one started by DeepBuild · one send-back · 0 open items
the agent’s own summary, folded below
A Claim Becomes a Verdict, by Example
Claim, check and verdict from the glossary, on one stop: the done gate, the hub’s judge, runs the checks itself.
Every Ask Gets Its Own Definition, Not Every Session
Sessions run for days, so done is per ask: an issue, or a prompt asking for a change, opens its own task.
Ask-task
Something you asked for, with its own definition of done. A long session holds many.
task_ref: #42
Typed by a person
Only a prompt a person typed opens one; a scheduled task, a subagent’s report, a continuation or a prompt that can’t be placed (unknown) never does.
Every attempt shares it
Each attempt on the task is judged against the same locked definition, in any session.
Sent again after /compact
After a compaction or a resume, the session hears its open asks’ requirement IDs again.
Done Is Written Down From the Old Code, Not the Work
Where those checks come from: as Claude Code starts #42, the hub has a separate job turn the issue into checks.
Inside the Drafting Job: It Holds the Base, Never the Work
That separate job, up close: its folder holds only the base commit, and tests prove it can’t look further.
Started like any job
The job runner records the job first, then its process ID and start time, before it writes the prompt.
Only the base is there
Its folder holds the base commit’s files and objects, so the agent’s diff has no way in.
Two proofs, both tested
A marker shows what it did read; failed reads from inside show what it can’t.
What the Drafting Job Writes: Tests From the Outside
Acceptance tests through what exists today: a page, a route, a command. Unit tests of new code are the agent’s.
| Your request is about | The drafting job writes | Example |
|---|---|---|
| A bug in code that exists | a repro of your steps, with the value from the issue | open the receipt for a 3-item cart; expect “$18.01” |
| A new feature | an acceptance test through a page, route or command that exists today | click Export, pick SVG; expect a file starting <svg |
| What must not change | your repo’s own tests, “no visible change” and the neighbors’ journeys, reused | the cart’s 14 unit tests; checkout looks the same |
| A function that already exists | a unit test, only when the issue is about that unit | roundCents(18.005) is 18.01 |
| Something no test can say | nothing: one early question, or your taste call at the end | “make it feel faster” |
Unit tests of the new code
Written by the working agentThey can’t exist in advance: nobody knows the new functions yet.
They count one wayA failing one sends the claim back. They never pass it alone.
Covered only by them?That requirement stays INCONCLUSIVE, and you’re asked whether to approve one.
Which files? Doesn’t matter
The tests drive a page, a route or a command. The agent can put the code anywhere; only behavior is seen.
Tied to your words
Each test names the requirement it covers, at the depth it needs: a unit test can’t close a journey.
Hard to game
It must fail today at its own check, each journey has a negative case, and hidden fixture variants catch a fit to the visible test.
When a Step Is a Goal: A Model Drives Once, Then It Replays
Some tests need an agent to click through. A model finds the path once, an assertion judges it, and the path replays.
A journey with one goal stepillustrative
Why
For a screen that doesn’t exist yet, or a repo with no test IDs, the drafting job can’t know the buttons in advance.
In the background
A goal run live is slow, so its journey runs only when a turn ends green, like any heavy test.
Only if it helps
Built in R1 (#581) only if the week-1 spike shows more drafted journeys then fail on the old code and pass on the fix.
Each New Check Must Fail on the Old Code First
Before a new check counts, the hub runs it once on the base commit. A bug check passing there proves nothing.
Failing Isn’t Enough: It Must Fail at Its Own Check
A new feature’s test must fail on the old code at the check it names. A crash or a timeout proves nothing.
| On the old code, the test… | Example: “export a document as SVG” | So |
|---|---|---|
| fails at the check it names | expect(render(doc, {format: "svg"})).toContain("<svg"), got a PNG | kept |
| passes | expect(render(doc)).toBeDefined() | dropped: can’t tell old from new |
| runs zero tests | a typo, so no test was collected | dropped: ran nothing |
| crashes before its check | exportSvg(doc): TypeError, not a function | failed elsewhere: redrafted once |
| times out on a missing button | click("Export SVG") waits 30 s | elsewhere, unless a hang fix names that deadline |
| catches the crash itself | expect(() => exportSvg(doc)).not.toThrow() | elsewhere, unless the error runs through the code under test |
The one redraft
A test dropped for failing elsewhere goes back once to the same drafting job, with only the crash’s file, line and message. They come from the old code alone, so it stays blind.
exportSvg(doc) doesn’t exist yet, so the redraft goes through render(doc, {format: "svg"}). It fails at its check: kept, and you’re never asked.
Only a redraft that fails elsewhere too sends you the early question.
A New Repo: A Do-Nothing Stand-In Plays the Old Code
With nothing to start, no test can fail at its check, so deep builds a do-nothing program to fail on.
200 and {}, or an empty page| Drafted test, empty repo: “GET /api/todos lists saved todos” | On the stand-in | So |
|---|---|---|
expect(await res.json()).toEqual([{title: "milk"}]) | fails at its check: got {} | kept, “proven on a stand-in” |
expect(res.ok).toBe(true) | passes on a program that does nothing | dropped: too weak |
expect(body.items.length).toBe(1) | TypeError: items is undefined | elsewhere: redrafted once |
The limits
deep builds it, never the drafter. One fixed form per kind, so it can’t be shaped to make a test fail.
Only where nothing starts. A new route in an app that already runs goes through the real old code.
Nothing to compare with. “No visible change” and latency checks are left out, and the definition says why.
Then the Definition Is Locked, and Only You Change It
Its checks proven, the hub locks the definition, recording three things. Four things can follow; read 1 to 4.
Five Ways to Decide When Work Is Done
Why draft, prove and lock? Each row is one way to decide done, as you would meet it, and what goes wrong.
Who Decides Done: What We Compare, and Why
Before the scores on “Who Decides Done”: each row is one column of the next slide’s table, and why it matters.
Who Decides What Done Means
Five ways to decide when work is done, scored on what each column measures and why it matters.
Five Verdicts, Each With a Reason You Can Act On
The glossary’s five verdicts in full: when the done gate gives each, and what it names so someone can act.
3/3 · receiptIt namesHow many clean runs confirm it, pinned to the commit.receipt shows $18.00It namesThe smallest failing case, and where it points: total.ts:42.paid run, no budgetIt namesThe cause, the owner, and since when.npm test || trueIt namesWhich check or requirement, and why.1 pass, 1 failIt namesThe runs still needed, or the check to approve.When Several Verdicts Apply, the Worst One Wins
A claim has several checks, each with a result; the claim gets the worst one, the highest rung. Two tries at #42.
A Flaky Check Passes and Fails on the Same Code
Try 1’s journey passed and failed on one commit: a flaky check. Rerunning it until it’s green is how it lies.
How Many Clean Runs Make a PASS Believable
How many clean runs is enough for a PASS? You pick p, the failure rate you accept; the curve gives n.
Read it as: if the check really failed a share p of the time, n clean runs in a row would happen less than 5% of the time.
After a Fail: Two More Runs, and Some Runs Count Neither Way
After a fail, the hub reruns the check at most twice. Five patterns, their verdicts; grey runs count neither way.
Why the Gate Sits in the Stop Hook: Catch It Before the Turn Ends
The gate isn’t a step at the end of a session. It acts at each stop that did work, while the agent can still fix things.
Two Kinds of Stop: “I’m Done” and “I Need You”
An agent stops when it thinks it’s finished or needs you. Each kind is handled, and neither is taken on its word.
“I’m done”
The checks runThe same way whatever it says, since a too-early “done” is what the gate is for.
FAIL: sent back in the same turn“sent back 1/3: receipt shows $18.00 · total.ts:42”
PASS: one line in the chat“PASS 4/4 · receipt”
“Want me to open the PR?”An offer to do in-scope, reversible work gets “proceed”.
“I need you”
Sorted by what it would lead to, not its wordsThe call it would make, the task and requirement it names.
Really yours: an ask cardA push, merge, deploy or spend; a step only a person can take; taste; a real choice.
It could do it itself: sent back with the tool“Should I run the tests?” or a page it can open in a signed-in browser you leased.
A saved decision covers it: answeredShown among what was decided for you, with an overrule.
Both hand control back
Either way the agent is about to wait for you, so that’s the moment to check, not every tool call.
Its own view is what’s checked
“Done” is often too early, and “I need you” is often something it could do.
Other stops
An empty “No response requested” gets a nudge to finish, at most three times. An API error isn’t a stop.
Inside the Stop Hook: Programs Decide, No Agent Judges
What happens between the agent saying “done” and the reply it reads. Nine steps; only programs decide.
Every Stop That Did Work Is Judged, Whatever It Says
Which stops are claims? A stop is the agent ending its turn; its Stop hook fires. Three stops in checkout-web.
Before Any Check Runs, the Validity Gate
That claim first meets a gate with no model: do its deliverables exist, and was all it cites run here?
Deliverables
What the definition says the work must produce. They must exist before anything runs.
Citations
Every file, line, test, run or link the claim cites must resolve, and have been read or run in this session.
No model
The gate reads the record: what the session read, ran and wrote. Nothing is inferred from its words.
Then the checks
Only a claim that passes the gate has its checks run against its locked definition.
How the Validity Gate Knows: It Reads What the Hooks Recorded
“Was it really run here?” is not a guess. The gate looks each claimed fact up in the record the hooks wrote.
Its source is the record
Every read, edit and command came through a hook and was written down, so “was it run here?” is a lookup.
Its rules are plain
A citation must match a row; a run must not be masked or run zero tests; each named deliverable must exist.
It costs milliseconds
No model and no check run: a claim built on things that never happened goes back at once.
Which Code a Check Runs On: A Snapshot, Then a Clean Copy
That “clean copy of its snapshot”: the work is frozen without touching your git, then checked out apart.
Never your git
Your index, branches and objects stay as they were. Nothing is fetched, and deep never stashes.
Clean worktree?
Then the snapshot is simply HEAD, and the checkout is made the same way.
Status on a match
A commit status goes only to a pushed commit whose tree is the snapshot’s.
One Check Run: Sealed Off, Timed, Its Tests Counted
In that clean copy, the hub’s checks-command runs one check sealed off, then records what happened.
Proof Depth: A Green Unit Test Can’t Close a Journey
Past the gate, the checks run. Each requirement names how deep its proof must go; deeper covers shallower.
Depth
Each approved feature or journey names how deep its proof must go: unit, integration, a browser journey, or live.
Deeper covers shallower
A journey satisfies a unit-level need; a green unit test never closes a journey-level one.
Coverage, claim by claim
Each check lists the requirement IDs it covers. A requirement no check covers can’t pass.
A negative case
Every journey includes at least one, so a check that can’t fail shows up.
A Second Model Reviews the Diff; Every Number Is Re-Run
Besides tests and journeys, R1 has two more kinds of check. Neither lets a model’s opinion make a PASS.
Its oracle
Every check names one: code, a model or a person. A PASS never rests on a model’s judgment alone.
Which model answered
Read from the job’s own output. Another model of the same family counts, and the verdict line says so.
Only the diff
A test plants markers in the transcript, diff and claim, and finds only the diff’s in the review.
Numbers, not prose
A number a claim states is checked by re-running what produced it, never by reading the agent’s text.
How a Review Finding Counts: Its Quote and Its Rule
The second model’s answer, checked by a program: a finding counts only if its quote and its rule check out.
Quote at its line
The quoted text must sit at the file and line it cites in the diff, byte for byte, after one space per whitespace run.
Rule in your rubric
Its rule must name a line of the review rubric your wiki holds. Dropped findings are counted, never sent.
Which model
Read from the job’s output. The change’s own model, or an unnamed one, makes the review uncounted.
Fast Checks Answer in the Chat, Slow Ones Land Later
The stop’s quick checks share a 10 s budget; the task’s own check goes first. The rest wait for a turn that ends green.
Which Stops Start a Heavy Test: Four Questions at Each Stop
The gate fires at every stop, but a heavy test starts only where the agent really stops: no send-back, no loop.
| Stop | What happened | Decided by | Heavy test |
|---|---|---|---|
| A 10:02 | read files only; “shall I go on?” | 1: no change | no |
| B 10:05 | edited; typecheck red | 2: sent back | no |
| C 10:06 | fixed; green; “want me to tweak spacing?” | 3: “proceed” | no |
| D 10:09 | green; “Done.” | 4: turn ends | starts on D |
| 10:09:30 you type “also make it bold”; a new turn | D keeps running; lands 10:10, stale | ||
| E 10:11 | green; “Done, it’s bold.” | 4: turn ends | starts on E; its PASS counts |
Heavy Tests Start When the Turn Ends, Never Mid-Work
Browser tests and full suites wait until quick checks are green and the agent stops. A run in flight is never killed.
| Time | The agent | A 5-minute browser test |
|---|---|---|
| 10:00 | stops; quick checks green; reply ends the turn | starts on A |
| 10:01 | you type more; it stops green, offers to go on: “proceed” | nothing: it’s still working |
| 10:02 | stops; typecheck fails: sent back | nothing |
| 10:03 | stops; quick checks green; reply ends the turn | D queued behind A |
| 10:05 | A ends: “FAIL on A, 3 stops back”, shown as A’s; D starts | |
| 10:10 | D passes: PASS on the final code |
The rules
Starts only when the turn endsQuick checks green, and DeepBuild’s own reply lets the agent stop. A send-back or a “proceed” means the code is about to change.
Never stoppedA run in flight finishes and reports on its own code.
Only the newest waitsOne running and one queued per check; newer code takes the queued place.
Stale stays staleA late result is labelled with its code and never sends the agent back.
Why not mid-work
Only the final code’s result decides PASS. Mid-work runs buy early warning at your Mac’s cost.
Its own reply decides
DeepBuild knows whether it just told the agent to go on. It never reads the agent’s words for this.
On the judged code
The test’s stack serves that stop’s snapshot, from a warm stack, not the folder the agent is editing.
When an Agent Is Stuck, or Its Change Is Too Big
Each send-back is a round (1/3, 2/3…). Two brakes end the loop: left, no progress; right, a change far too big.
Bug Fix #42 (1 of 2): Checks First, Then a Failed Try
Part 4 on one bug, Claude Code fixing #42. Steps 1 to 9: done is fixed blind, the agent claims, checks say no.
Bug Fix #42 (2 of 2): The Second Try Passes, the PR Closes It
Steps 10 to 12: Claude Code stops again, every locked check passes, and the PR is allowed to close the issue.
Done Means Switched On: What a PR Needs to Say Closes
Behind that “Closes #42”: a PR claim also runs release checks merged with main, and live ones where named.
A UI Change, Judged (1 of 4): The Checks Come First
Your case: done means the total shows above the fold, with before and after. First, what done means, written down.
An agent writes them
Your own agent, in a job apart from the working session, drafts the checks from the issue alone.
Facts, not looks
“Above the fold” and “nothing else moved” are measured from the page, so a program can decide them.
Proven first
The fold check must fail on the old page and the others must pass. One that doesn’t is dropped, and you’re asked instead.
A UI Change, Judged (2 of 4): Who Writes the Code
“Above the fold” runs as code. Two authors wrote it, and neither is the agent doing the work.
1 · DeepBuild’s own code
Written once, the same in every repo
2 · This task’s check
Written for issue #61 by the drafting job, from the old code only
Your repo has no such tests?
That’s the usual case. The drafting job writes them at the start, from the issue and its screenshot.
A model writes, code decides
The drafting job is your own agent, headless and blind. Once written, its test is plain code that runs.
What can’t become code
“Looks clean” has no test. It comes to you: as an early question, or as a taste call at the end.
A UI Change, Judged (3 of 4): Two Lanes, Two Screenshots
Each stop that did work: quick checks while the agent waits, then the journey screenshots both sides.
Only what fits is held
A check waits for the stop only if its usual time fits; none fit, no hold. Tool calls never wait.
Its own copy of the app
The journey runs the snapshot of the agent’s work in a stack DeepBuild starts, so nothing needs to be up in the session.
Every stop, not only the last
Each stop that did work is judged, so a broken step comes back the minute it happens.
A UI Change, Judged (4 of 4): Facts Checked, Taste Asked
The facts passed, so the one question left is taste. It comes to you with the evidence beside it, not as a model’s guess.
A rule can tell what changed
Boxes and positions come from the page on both sides: what moved, by how much, and what must not.
You decide what’s good
The before and after reach you side by side, the change highlighted; one tap answers.
An agent can describe, not judge
It may caption the change; a model’s opinion is a reading, never the verdict.
The Finish Line (1 of 3): The Last Stop Runs Everything Still Owed
The agent says it’s finished. Six steps run before anything counts as done, the same at every stop.
Nothing special about “last”
The last stop is judged like every stop. It just has nothing left to defer, so every check still owed runs.
Depth decides
Your task named its proof depth: if it’s a journey, the journey must pass at this commit, whatever ran earlier.
Merged, not just branched
A PR’s checks run on its commit merged with main, so it works where it will land.
The Finish Line (2 of 3): One Verdict, and What It Lets Happen
Five verdicts, each with a next step. Only one of them lets the PR say it closes the issue.
| Verdict | It means | What happens next |
|---|---|---|
| PASS | every requirement passed at its depth | “Closes #61”, a green commit status; the PR can merge |
| FAIL | a check failed, with the line it names | sent back into the session, up to three times, then it stops |
| BLOCKED | a check couldn’t run: the app wouldn’t start, a device is missing | one ask to unblock it; never counted as a fail |
| INCONCLUSIVE | ran, but not enough: a flaky test, too few clean runs | “Part of #61”, listing what’s left to prove |
| INVALID | the claim cites what doesn’t exist, or no check is at its depth | nothing passes until the evidence is real |
Only PASS closes
“Closes #61” needs every requirement proven; anything less says “Part of #61” and lists the rest.
The agent can’t close it
Closing the issue by hand is refused while its definition hasn’t passed.
A stuck loop stops
Two stops with nothing new proven, or three send-backs, and it stops asking the agent and tells you.
The Finish Line (3 of 3): One Card With the Whole Story
When a task finishes you read one card: the verdict, each requirement with its evidence, your calls and what’s left.
Six Defense Layers (1 of 2): Rules, Guards and Roles
Can an agent cheat this loop or get around it? Six defense layers say no. Here three, each catching one thing.
Six Defense Layers (2 of 2): You, a Sandbox and the Record
Three more layers, the same way: one picture each, with the threats it stops at the bottom.
Twelve Threats, and Which Layer Stops Each
Rows: ways things could go wrong. Columns: the six layers of the last two slides. A diamond: that layer stops it.
Twelve More Threats, and What Stops Each
The table had room for twelve. Each card here: a threat, an example of it, and what in the design stops it.
MCP tools the guards can’t see
e.g. A server update adds a tool that deletes.
Stopped by: It waits for your approval once; an unknown tool counts as a change.
Approvals that drift
e.g. A run tries one more step than you saw.
Stopped by: Your yes binds to the plan’s digest and your click’s token.
Secrets
e.g. A key pasted into a chat.
Stopped by: Redacted on the way in, and a “rotate this key” item opens.
Untrusted repos
e.g. A cloned repo’s .deepbuild/ would run commands.
Stopped by: Nothing runs until you trust the project; until then, watch only.
Tampered updates
e.g. A swapped release download.
Stopped by: Release manifests signed by an offline key whose public half is built in.
Extensions that host shells
e.g. A terminal plug-in can run anything.
Stopped by: Only by the plainly named run-as-you permission, revocable at once.
A panel editing as you
e.g. An agent-built button writes under your name.
Stopped by: Only the editor panel, or a plug-in you granted edit_as_you, with your input.
A plug-in posing as the app
e.g. A fake toast, or a fake secret field.
Stopped by: Its overlays stay in its panel; no secret fields, no status colors.
Pages an agent made
e.g. An HTML report that calls out.
Stopped by: Opened in a wrapper that blocks every network request (R2).
Sound or recording
e.g. A plug-in that starts the microphone.
Stopped by: Sound only after your gesture; mic and camera only while a shortcut is held.
Media that attacks its parser
e.g. A crafted video file.
Stopped by: Decoded only in a sandboxed worker with no network, under caps.
A shared piece’s network
e.g. A game piece that phones home.
Stopped by: Only its one declared relay, and only after you click Join.
One Guard Engine: Each Rule Proven on a Call and Its Twin
The fast rule and the fail-closed guard from the threat table are one engine: each rule is data, proven twice.
MCP tools too
Each tool counts as read, change, send or destructive, from a facts file or the session’s recorded list. Unknown is a change.
Hints only raise
A readOnlyHint or a get_ name never makes a tool read; a delete_ name makes it destructive.
Hub up
deep-hook sends the entries that matched; the hub decides by scope and mode: record, warn, ask or deny.
Hub down
deep-hook applies the fail_closed entries and allows the rest, so an agent is never stuck.
How deep-hook Matches a Command: Unwrap, Then Compare
The guard engine on one call: deep-hook finds what the command really runs, compares each rule, then acts.
Your Written Rules, Enforced: What Backs Each Line
Many guards start in your own rule files. A rules page shows what enforces each line of your CLAUDE.md.
Read at setup
Every rule file you keep for agents: CLAUDE.md, AGENTS.md and the like, for every agent you use.
One rules page
In the wiki: each rule with what enforces it, a check, a guard, a requirement, or text only.
Push, PR and merge
Go ahead only when the thread’s ask names them or a rule covers them, through gh or an MCP tool.
Only you change it
An edit made outside an agent’s tool calls changes the page; an agent’s becomes a proposal.
A Command That Could Destroy Files Runs After a Copy
When a destructive command’s reach is unknown, the folders it names are copied first; then it runs in place.
Copy-on-write
APFS on macOS, btrfs or XFS on Linux, ReFS on Windows. The copy is kept for a set time, so the run can be undone.
No such file system
On ext4 or NTFS, a command whose reach can’t be known becomes an ask instead.
What your yes covers
What you were shown, never an extent nobody knew. So an unknown reach gets a copy or an ask.
A ceiling
On files and seconds, set below the agent’s hook timeout. A copy that would pass it is dropped, and the command asks.
Six Ways to Look Done (1 of 2): Bending the Checks
Say Claude Code wants #42 to look done without being done: three tricks on the checks, and what catches each.
Six Ways to Look Done (2 of 2): Dodging the Judge
Three more, this time on the judge, the hub’s done gate: switch off its hooks, talk around it, or grade itself.
Part 5: Extend and Compose
Parts 1–4 built DeepBuild and its trust. Part 5: every place it can be extended, an example of each, how pieces compose, and the rules that keep it safe.
Every Extension Point, on DeepBuild’s Tree
Part 1 said features on top of the core are extensions. Here is each place one plugs in, how, and who may write it.
Five Ways an Extension Arrives, From Data to Compiled Code
Who wrote an extension decides how it arrives: from data anyone may write to code only DeepBuild compiles.
← anyone may write itcloser to the core →
Data in a pack
RUNSnever by itself; the core expands it at check
WHOanyone
CHECKEDonce per version, with each kind’s kit; then frozen
E.G.report@1’s KPI card
WebAssembly logic
RUNSin sandbox@1: no imports; fuel, memory, stack budgets
WHOanyone, in a piece or a pack
CHECKEDthe logic subset, then its fixtures
E.G.the rocket piece’s rules
A sandboxed process
RUNSits own process in the OS sandbox; TypeScript, or any language over JSON-RPC
WHOyour agent, or anyone outside DeepBuild’s release
CHECKEDconformance, its tests, a render, a dry run, an access check
E.G.ci-status, the stocks view
In-process TypeScript
RUNSinside the hub, as a plain function call
WHOonly DeepBuild’s signed release
CHECKEDpinned, and checked before it loads
E.G.the done gate, resolvers, adapters
A compiled canvas module
RUNSin the app, as Rust, fixed at startup by the seal
WHODeepBuild’s repo only, by a merged release
CHECKEDits interface’s kit, then the seal
E.G.the data module’s vector field
owner/name ID, a version, the digest of its files and, optionally, its publisher’s key, trusted on first use.The manifest is read as data before any code loads; a signature that doesn’t verify is refused.Every Slot Has a Kit That Must Fail a Planted Wrong Fill
Each place an extension plugs in names an interface, how many may fill it, and a kit. Here: check kinds.
Interface
Each slot names one, name@major, with a digest per minor; only a break takes a new name.
How many
One fill (a check kind, an adapter, an index) or many (resolvers, sources, channels, views, layers).
Kit
The slot’s test cases. One runner in the conformance package runs every kit.
Planted wrong fill
A broken fill the kit must refuse. It is how a slot proves it is hard to fill wrongly.
A New Agent: Its Adapter Says What It Can Do
Slide 40 showed an adapter mapping hooks to shared shapes. Adding Cursor (R2) also means declaring caps.
Cursor’s adapter (R2)illustrative
Every cap
holdStop, wakeIdle, steer, followUp, answerPermission, nativeTools, mcp, rewrite, editInput, errorTurnHook, startTurn.
Seen, not claimed
A cap counts in a session only once our hook has fired there, trusted, on a version its facts cover.
One per agent
The adapter@1 slot takes one fill per agent, and one adapter owns each session.
A Facts File per Agent Version, and a Kit of Broken Fakes
Agent quirks change every release, so they live in a data file per version; an uncovered version is only watched.
Its facts fileversions illustrative
Each field names the core rule that reads it, with a conformance case.
The adapter kit’s broken fakes, each must fail
A duplicate event ID; an event after a stop; an answer delivered to another session; a steer that outlived an interrupt; an acknowledgement with no transcript sign; a driven fake that declares a cap it doesn’t honor.
Agents with no adapter code
An agent that speaks ACP, the Agent Client Protocol, needs only facts: bridge version, permission quirks, timeouts (R6).
Hook Handlers: Many Extensions, One Reply, Typed Context
Any extension can also answer a hook with deep.on. When several do, the hub joins their replies by fixed rules.
deep.on(event, handler)
On session.start, tool.before, tool.after, prompt.submit, agent.stop, merges and releases; it returns context or a deny.
A fixed order
By extension ID, never by load or finish order. Contexts join up to the hook’s bound, cut from the end, never ahead of a deny.
Typed context
Outside DeepBuild’s release, only templates its manifest declares, filled with handles, numbers or values from a closed list.
Never in a template
An outside reading, a source’s free text or transcript text: the handler is recorded as failed, naming the field.
Twenty Hub Slots, Each With Its Planted Wrong Fill
Each card: a deep.register… call, interface, fills, planted fault (red), release. Polled sources (R2) not shown.
A Check Kind for Work Beyond Code: Totals That Reconcile
Part 4’s done gate judges by checks. Work that isn’t code needs new kinds of check, which a plug-in adds.
A money plug-in’s checkillustrative
- The drafting job picks it for work that closes books.
- Its kit’s planted runners must fail (342).
- The agent that did the work can’t be its only author.
R2
Service: an endpoint answers in shape and time. Data: a query’s rows hold. Document: each number matches its source.
R3, R6, later
Setting and machine checks with hosts (R3); playtests with logic (R6); money with the money extensions.
Only checks earn it
A runner can’t return a pass without its results; the validator alone makes the verdict.
A Channel to Your Phone: It Carries, the Hub Decides
Reaching you somewhere new is a channel plug-in. It carries asks both ways; the hub decides what an answer counts as.
paseo’s channel (R2)illustrative
Its kit plants
a channel that reports delivered with no acknowledgement, and one that marks an answer signed with no valid signature.
Many may fill it
Your phone, a chat app, email, a text message (which carries only a link).
A Map Layer: Every Row Cites What Names It
Slide 274 showed live rows on the Map. A plug-in adds them with deep.registerLayer; each cites its support.
A services layer (R2)illustrative
The map.layer@1 kit plants
a row citing nothing; rows that all cite one reading naming none of them; a row in a status color.
Plug-ins in Depth (1 of 4): Built From Blocks
Piece 4 of the rings, up close: a plug-in your agent writes from a sentence, built from blocks the hub runs.
Installing ci-status: Read, Hash, Check, Then Ask You Once
Your agent wrote that manifest. Six steps take it to a running plug-in; you appear once, in step 4.
Plug-ins in Depth (2 of 4): One Call, Inside a Grant
Block 1 at work: the hub makes the plug-in’s call, inside its grant (what you allowed it). Red: a call outside it, refused.
What a grant is
Only limits the supervisor enforces at runtime: the OS sandbox, an egress filter, path containment.
Approved once
On the trusted path (the app, or the CLI after Touch ID), right from the denial.
Changed since checked
A plug-in whose files changed since its checks ran doesn’t load until they pass again.
Plug-ins in Depth (3 of 4): Reusing Another Plug-in’s Data
You want a release board that shows CI status. ci-status already reads GitHub, so the board reuses its readings.
Reading
One value a plug-in records, with its source and the time it was true: here, one CI run.
Typed edge
A data shape one plug-in promises and another says it uses. The hub checks both at install.
Compose first
A weekly brief of stocks and CI is two plug-ins’ readings, a schedule and a send: no new data code.
Plug-ins in Depth (4 of 4): Trying a New Version Safely
ci-status v2 arrives. The hub runs it beside v1, replays the board’s own tests on its output, then asks you once.
Shadow copy
A new version running beside the one in use, on the same events. Its output is recorded, never sent on.
Contract test
The user’s own tests, here the board’s, replayed on the new version’s output. A fail stops the install.
A break, a new name
If v2 removed or retyped a field, it would be ci.run@2; an added optional field is a new minor of ci.run@1.
A Stocks Plug-in From One Sentence (R2)
The plug-ins so far, end to end: one sentence becomes a stocks panel in five steps, with one approval from you.
How Add Anything Is Measured: Seven Sentences, a Reading
The stocks view is one of seven test sentences. How well agents build them from the docs is measured, not passed.
A Plug-in’s Runs Are Judged Too: Schedules and Actions
Part 4’s verdicts apply to plug-ins too: each scheduled run and each action is judged by what the hub recorded.
Plug-ins That Host Something Live: Terminals in Tabs
One test sentence hosts your agents’ terminals in tabs. Live blocks make it work, and keep agents from typing in.
Stream
Output too fast to be state, to one panel: a terminal, a log, a REPL. Ordered; it applies backpressure.
Run as you
A shell can’t be fenced by a command list. The supervisor still tracks every process, by run token.
Device bridge, port (R6)
Gear a piece reads, such as a pen; a piece’s port opens only after a person clicks Connect.
Handoff (later)
A long-lived piece hands its open sessions to its next version, with a rollback, so an update kills nothing.
The App Extends Itself, From the Lowest Rung Up
Every view can change. Your agent composes pieces you have first, then edits a view document, then writes code.
Suggestions (R2)
Built in a copy on your plan, shown only after the same checks; never an ask; Not now mutes it for a month.
Show what changed
A title-bar switch outlines every added or changed piece with the sentence it came from: Roll back, Remove.
Side by side
Your version runs sandboxed while the shipped one stays one click away. Only the card and access prompts are fixed.
A Pack Brings GPU Work as Data: A Toon Look for the Rocket
Slide 179’s rocket.cel was one operator. A pack carries several, plus step functions they share.
A toon packillustrative
use(): one ramp serves the material and the outline, so they band alike. Its registry, gpu.function@1, lands in R2; pack functions and composed graphs in R6.Adding a Kind (1 of 2): A Pack Kind, Built From Data
One registry in use: kind@1, filled by a pack. An illustrative report pack adds a KPI card to the Q3 chart.
It can never
Be backed by code, bring a builder, arrays or operators of its own, take a first-party name, or change inside a published version.
Listed for agents
deep_kinds shows its schema, an example, its kit result and its cost at defaults.
Trust
A kind the working agent wrote judges only that agent’s own claims until you approve its pack.
Adding a Kind (2 of 2): A Code Kind, Through the Seal
New code means a DeepBuild module. A real one: the data module’s vector field, drawn as arrows and flow lines.
Only first-party
Kinds backed by code come only from canvas modules, before the seal. Packs can’t add them.
Checks come free
Contribute to the core’s arrays (bounds, glyph boxes, strokes) and the core’s checks read the new kind unchanged.
Others reach it by data
A follow_stream constraint carries a dot along a stream: data’s own entry, so motion names no data kind.
Swapping a Backend: One Interface, Proof Before the Switch
A module implements its interface, as a seam’s backend does (slide 196). Here a second engine might replace Rapier.
Equivalence
bit: the reference’s hashes on every fixture. measured: within the behavior kit’s tolerances, as physics is.
State
canonical: a documented layout any implementation reads, as logic’s is. backend bytes: only that crate loads them.
Runtime digest
Names every measured or backend-bytes implementation. Saves, matches, goldens and receipts carry it, so evidence never mixes.
Seams too
Each platform part (GPU, display, fonts, input, audio, network …) is an interface; its backends are implementations.
Composing at Every Level: Edges, Not Calls
Slide 353 joined two plug-ins by a typed edge. The same rule holds at every level, up to a whole piece.
A Recipe Composes Primitives: The Rocket Piece, Unfolded
Recipes compose too. The rocket piece is one item naming a recipe; it unfolds into kinds from modules and packs.
The rocket piece: one itemillustrative
module_missing, naming it, and a check that needs it is BLOCKED. Nothing is quietly left out.It declares what it needs
Each recipe names the kinds, canvas modules and packs its inputs need; packs name packs by exact version.
It brings its checks
physics.determinism, logic.determinism, physics.query, honest_numbers: in the brief, so none is dropped.
Change one thing
Inputs first; past them, a patch breaks out one derived item (211).
A Blueprint Bundles a Way of Working: Close the Month
The biggest composition: a proven way to do a kind of work, installed like a plug-in, built from pieces you know.
One Closure Rule, and Contracts That Can’t Drift
Two rules stop extension points drifting: every list is declared one of three ways; every shape is versioned.
logic@1’s exports: each with since, a minor and a frozen digest d1:<hex> of its RFC 8785 bytes, in schemas built from one closed list of node types.Hard to Get Wrong: Eight Rules, and Where Each Bites
All of this part’s safety, on one page. Each row: a rule, the mistake an extension could make, and what happens instead.
Part 6: In Use
Parts 1–5 showed how DeepBuild works and grows; now using it: first run, MCP, CLI, leases, the box, phone, wiki, and how it learns from past work.
What Ships On by Default: Eleven First-Party Extensions
Part 6 walks through what you use. First, what is already switched on: eleven parts that do the daily work.
.deepbuild/ guard and project trust. In safe mode the hub starts with no extension at all, and that floor and the fail-closed guards still hold.First Run (1 of 2): One Button, and Your History Becomes a Wiki
Day one: one Set up click starts the hub, adds hooks in watch-only, and turns your history into a wiki of notes.
First Run (2 of 2): A Repo Gets Its Checks at Its First Session
A repo’s spec: the approved checks Part 4 reuses, drafted at an agent’s first session there; you approve once.
MCP Tools (1 of 3): The Agent Checks Its Target and Searches
Part 1’s optional MCP tools, in use: mid-task, Claude Code asks DeepBuild three things through deep mcp.
MCP Tools (2 of 3): One Question for You, and Work Goes On
Part 2’s ask, raised with deep_ask: a card for you, while Claude Code keeps working until your answer lands.
MCP Tools (3 of 3): A Figure, and What No Tool Can Do
Left: deep_show puts a figure on its claim (render-back, Part 3). Right: all eleven tools, and what none can do.
At a Terminal (1 of 2): See Every Session, Answer One Ask
The deep CLI, Part 1’s way in for you and for scripts. Two commands: see every session, then answer one ask.
At a Terminal (2 of 2): A Health Check and an Off Switch
deep doctor says what is wrong and how to fix it. deep off puts every gate back in first run’s watch-only.
Leases (1 of 3): A Port Already Held Is Refused, Not Fought Over
The glossary’s lease, in use: api holds port 3000, so the hub refuses checkout, names api and offers 3001.
A Stack per Worktree: deep env up Hands It Its Ports
Where checkout’s 3001 goes: env-local leases each port done.yaml names, then passes it into the stack.
Leases (2 of 3): A Lease Ends Only When Its Processes Are Gone
api ends, but its test account stays leased until the supervisor (Part 1) proves all that api started is gone.
Leases (3 of 3): An Hour on One Mac, and Every Kind of Lease
The hub’s leases on one Mac for an hour: black is api (Codex), yellow is checkout (Claude). Below: each kind.
lease.kind@1: how its keys match, a cap, a cooldown and a cost. Two leases on one key are refused unless both are shared.Two Sessions, One Repo: Notices, Dry Merges, Hard Stops (R2)
Leases keep sessions off each other’s ports. For the code, a session map tells each agent what others change.
Session map
A table rebuilt from the record: agent, worktree, branch, issue, changed files, commands, leases. R1 keeps it already.
Dry merges
git merge-tree between branch tips in the hub’s own mirror, off the hook path: no worktree or index is touched.
Hard stops
A taken migration number or unique name, or a leased port, is denied with the next free value.
Facts, not words
Notices carry paths, line ranges, issues and session names, never another agent’s text.
Plan Windows, Not Dollars: DeepBuild Waits at Your Reserve
Sessions also share your plan. Its limit is windows, not dollars; DeepBuild reads them and keeps a reserve.
Read locally
From the status line and session logs, with no credential read and no call to a vendor with your tokens.
Missing is unknown
A window a reading leaves out is unknown, never zero, and another account’s sign-in isn’t a reset.
Per task
Tokens summed per session, claim and issue, subagents included, with what the same work would cost on a key.
No reading yet
After 30 minutes with no window while a job waits, one ask: run up to 10 jobs a day without one, or connect the CLI.
Start a Session From the App (R2)
You type a task in the main box; a start card shows what will start, where and how. Read 1 to 6.
deep command or plug-in starts one. A plug-in’s request waits as a draft in the box.A Worktree of Its Own for Each Session You Start (R2)
A start from the main box gets its own folder and branch, owned by its task until you remove it. Read 1 to 6.
Who Does the Work: Pick an Agent, or Let DeepBuild Route (R2)
Pick none, and the card names one by the first rule that holds, skipping an agent at your reserve. Read 1 to 4.
One Box: Steer, Follow Up, or Answer a Card in Words
Words for the running turn, the next turn or a card; Steer and After this turn are R2, the rest R1. Read 1 to 6.
Every Session in One Place (R2)
Sessions from the app, your terminal and the desktop apps share one list, and one that ended resumes here. Read 1 to 5.
One Account per Session (R2)
An account is an agent home you signed into yourself; the start card names one per session. Read 1 to 5.
CLAUDE_CONFIG_DIR or CODEX_HOME.Your Phone (1 of 2): One Tap on an Ask, Signed (R2)
A channel carries asks beyond the app, here to paseo’s phone app (paseo runs agents). Read 1 to 8.
Your Phone (2 of 2): One Thread, Closed Everywhere (R2)
Part 2’s one thread per ask, on three surfaces: one answer closes all three. Below: who may answer what.
The Wiki (1 of 3): Every Line Keeps Its Source
The wiki your agent built at first run: plain markdown about you and your repos, each line with its source.
The Wiki (2 of 3): Agents Read a Slice, Then Search by Handle
A handle is a pointer like session:01K…#m42. Agents get a short slice, then find and read the rest by handle.
How a Wiki Line Is Written: Its Quote Must Be at Its Handle
First run read your history by handle too: your agent cites a handle and a quote; a program checks both.
At its handle
Byte for byte in the slice the handle names, once Unicode forms and runs of spaces are normalized.
Keys in the quote
A path, command, port, variable or version the line states must appear in its quote, or it reads inferred.
Checked again before use
Before a line is used, its quote is looked for again; gone from a changed file, the line reads drifted.
The Wiki (3 of 3): What It Learns, It Can Roll Back
An agent proposes what it learned (deep_propose), never writes it. A change starts small, widens while it helps.
Learning From Past Work (1 of 8): Where Each Lesson Goes
Eight things that happen in your work, and the one place each lesson lands. The next slides take them one at a time.
Learning From Past Work (2 of 8): A Base That Learning Can’t Touch
Two layers. Learning writes only the top one; the bottom one is yours. Refusals name what they protect.
The base: only you change it
the kernel’s two rules and the four invariantsthe specs and checks you approvedyour decisions and answersevery rule you typed, always in the start sliceChanged only in your words, as a diff you approve.
The learned layer: what learning may touch
wiki claims, and the slice agents read at startrules DeepBuild offers, such as taste rulesimprovements to extensions and playbooksstep specs, such as how to run shop’s journeyshow definitions get drafted, and compositionsA closed list: a change aimed anywhere else is refused.
The hub, two learned changes it refusesillustrative
Learning From Past Work (3 of 8): Every Fix Leaves a Record (R2)
Bug #42 from Part 4, after it merged. What went wrong, why the old checks missed it, and what proves the fix now.
fix record · checkout-web #42illustrative
Learning From Past Work (4 of 8): The Next Definition Reads Old Fixes (R2)
A new task in another repo. The drafting job finds the rounding fix and turns its gap into a check for this task.
.deepbuild/ · invoices-api #7, draftedillustrative
Learning From Past Work (5 of 8): The Gate Learns What Done Means
When checks miss bugs or keep failing on things you don’t care about, the next definitions change, not the old ones.
What the hub saw, and the change it proposesillustrative
Learning From Past Work (6 of 8): A Lesson Spreads Only When Proven
A change starts in the session it came from. It reaches more of your work only when a replay it can’t tune says it helps.
Frozen before it runs
The task IDs, variants, models, repeats, metrics and comparison rule are fixed before either side runs.
Nothing quietly dropped
A missing, failed or duplicated pair stays in the count and never shows improvement. A missing metric stays missing, not zero.
Learning From Past Work (7 of 8): “What Did You Learn This Week?”
Ask in plain words. You get every learned change with its evidence, scope and replay, and can roll any of them back.
The app’s box, or ask your agentillustrative
Learning From Past Work (8 of 8): Later, Every Lesson Learned Once (R4)
R4, Keep, is the release about past experience: a mistake one agent made, no agent makes again.
Guards for failure classes
A class that keeps coming back, such as a kill by name or a port fight, gets a guard that only watches, then warns, then blocks.
Fix it at the highest level
Structure first, then types, a lint that names the fix, a test, a hook. A note in a rules file comes last.
A premise review
When two fixes that share an assumption fail the same check, the assumption itself goes to your inbox.
Every agent’s memory, in one wiki
Claude Code’s and Codex’s memories compiled into the wiki, lessons ranked for you to keep or remove.
Configuration evals, #112
Before an instruction file, skill, hook or policy changes, real past tasks are replayed with and without it.
Taste rules, #109
The same taste answer three times offers a rule, bounded by checks on element boxes; never for prices or totals.
Part 7: Build It Right
Agents build DeepBuild from its issues. First: how its design makes their work hard to get wrong. Then the numbers version 0 must hold, six weeks of work, the rule that decides, and the cuts.
Looks Right, Is Wrong: A Resolver That Passes Its Test
Agents build DeepBuild issue by issue. One builds #23’s resolver: its test goes green, and it’s still wrong.
1Passes only what it sees
The resolver above: its one test repeats the same words.
2Special-cases a fixture
A plug-in that spots its kit’s fixture repo by its paths, and is right only there.
3Edits a test
#42’s receipt check changed to expect $18.00, or a skip marker added.
4Blesses its first output
The first physics hash it records becomes the golden, bug and all.
How We Know It Works: Twelve Layers of Proof
Twelve layers stand between a design sentence and a wrong build. Each row: a wrong program that layer stops.
Every Criterion Has an ID, and Each ID Needs a Test
Layer 1. Issue #23’s criteria get IDs from their words; tests name the ID they prove; one lane checks both.
An ID from the words
#23.<8 hex>: the start of the SHA‑256 of the criterion’s normalized text.
A test names its ID
A tag in the test itself, so the link lives in code, not in a table kept by hand.
The trace lane
Part of the local preflight, the checks the repo runs on the Mac before a merge. From week 3 the gate reads the same tags.
A checked shape
A lint flags a criterion that doesn’t name what it observes, a threshold with its unit, a wrong case that fails it, and its depth.
Tests First, Written by a Job That Never Sees the Code
Layer 2. Part 4’s blind drafting job, turned on DeepBuild: one job writes #23’s tests, an agent the code.
A Test Counts Only If It Fails on a Wrong Program
Layer 3. A fix’s test must fail on the merge base, on its assertion; new code’s must fail a twin or a mutant.
Three wrong programs that do count
The merge base, for a fix
#42 before the fix rounds before the coupon. The receipt test fails on its assertion, $18.00 ≠ $18.01. It counts.
A twin the criterion names
#23 names one: a resolver that trusts its own count of what was charged. Its budget test must fail that twin.
A mutant of the new lines
New code has no old version to fail on, so the trace lane makes small wrong copies of it: next slide.
A Mutant That Survives Shows a Line No Test Checks
Layer 3, continued. For new code, the lane makes its own wrong programs: small edits to the lines added.
Mutant
A copy of the code with one small change, such as < for <=: a wrong program the lane makes itself.
A survivor
A line the tests run but never check. It is listed with its diff, so the gap has a name.
Kills nothing?
A criterion whose tests kill no mutant and name no twin is INVALID for that change.
Where it runs
cargo-mutants on Rust, StrykerJS on TypeScript: in the release preflight and on demand, never on push.
A Rule That Says “Every” Is Tested on Thousands of Cases
Layer 4. One example can’t test “every”. A generator draws cases, shrinks a failure, and keeps it.
Universal words
A rule with every, never, only or always gets a generated test that names its generator and the criterion.
Shrunk, then kept
A failure is cut down to its smallest case, which stays as a fixture, a saved test input.
1,000, then 100,000
Cases per rule in each local preflight, then in the release one, from recorded seeds: fast-check, proptest.
The fix here
n found by exact comparison on p. A p of 0, 100% or outside them makes the check BLOCKED, naming it.
An Ask’s Life Is One Table, and Every Order Is Tried
Layer 5. An ask moves only by its table, and a test tries every order of events in a small world.
The Hub Crashes at Every Write Point, One at a Time
Layer 6. The hub is handed its clock and disk, so a seeded test runs it on fakes and cuts power at any write.
One Crash Run: Power Cut at Write Point 5, Then Reopen
One run: scripted peers drive the hub on a fake clock and disk, and the cut drops what wasn’t synced.
Held-Out Cases: Fitting the Visible Ones Isn’t Enough
Layer 7. An ask’s key comes from its fields, not its words. Three resolvers meet #23’s key file.
Held-out variants
The gate runs each fixture’s siblings, never sent to the agent; the preflight draws fresh ones each run: renamed IDs, a shifted time, an extra row.
Seeded kit cases
Each hub slot’s kit draws more cases at install, from a seed recorded then, never shipped with its guide.
A planted fill per rule
Each kit rule has its own wrong entry that breaks it alone, and each item a kit declares its own broken fake.
Differential Tests: The Fast Path Must Equal the Slow One
Layer 8. Where DeepBuild keeps a fast path, a test compares it with the slow path it stands in for.
Pictures That Check Each Other: Reftests and Relations
Layer 8, for pictures: two documents that must draw alike, or a change whose effect is known ahead.
Reftest
Two documents meant to look the same, drawn on the same machine and compared. No stored frame needed.
Relation
A change to the input whose effect on the output is known ahead, so the answer needs no golden either.
Planted twin
Each relation ships a wrong program it must catch, so a relation too loose to fail proves nothing.
A Golden’s First Value Must Come From Outside the Code
Layer 9. A golden, a stored result a check compares against, catches change. It can’t catch a first mistake.
GPU goldens
A first blessing waits until the fixture’s paper-worked and CPU-reference checks pass on the same commit.
A driver update
Blessed by drawing again the commit the goldens were recorded at, never a later one.
A CPU reference
Counts as an answer only once it matches numbers the issue states, and its own planted twin fails.
A Golden Is Positive, Negative or Untriaged
Layer 9, continued. Positives pass, known-wrong results fail by name, and new ones decide nothing.
Positive
A result you blessed. A fixture may keep one per backend fingerprint: the GPU, OS and drivers it ran on.
Negative
A result known to be wrong, kept with its bug, so the bug coming back fails by name.
Untriaged
Anything new. An agent that re-records a golden only adds one of these, and it decides nothing.
A Pixel Tolerance Gets a Ceiling and a Window Bound
Comparing pictures needs a tolerance. “Within one code on 99.9% of pixels” lets 0.1% differ by any amount.
The Cheat Corpus: Ten Known Hacks the Gate Must Refuse
Layer 10. Beyond Part 4’s six tricks: hacks agents have been caught using, each planted as a false “done”.
Borrowed From Projects That Already Do This
None of these layers is new. Each comes from projects that learned it the hard way.
| Technique | Who already does it | Where it lives in DeepBuild |
|---|---|---|
| Criterion IDs traced to tests | the Rust Reference, OpenFastTrace | the trace lane: no “Closes” without a tagged test |
| Tests the solver never sees | SWE-bench; EvalPlus, about 80× more inputs | held-out variants at the gate and in the preflight |
| Fails before, passes after | SWT-Bench | a fix’s test fails on the merge base, for its reason; new code’s tests fail a twin or a mutant |
| Mutants of changed lines | Google; cargo-mutants, StrykerJS | the trace lane’s mutation runs |
| Generated cases, shrunk | QuickCheck at Volvo and Klarna; fast-check, proptest | every rule that says every, never, only or always |
| Every order of a protocol | TLA+ at AWS | ask and lease tables, walked in a small world |
| Simulation with faults | FoundationDB, TigerBeetle; SQLite’s crash tests | the hub on a handed-in clock and disk |
| Generated inputs, compared | Csmith, Wasmtime’s fuzzing; GraphicsFuzz | inputs across two engines; rendering relations |
| Reftests with bounded fuzz | web-platform-tests, Firefox, Chromium, Unreal | reftest pairs; a ceiling and a window bound |
| Golden triage | Skia Gold; Unreal’s alternatives | positive, negative and untriaged results |
| Reward hacks as tests | OpenAI’s monitoring work, METR, ImpossibleBench | the gate’s cheat corpus |
| The ecosystem before release | Rust’s Crater, JetBrains’ Plugin Verifier | everything made or shipped, rerun; new failures hold it |
| Exact codes, fixes applied | rustc’s UI tests and run-rustfix | each case names its exact codes; a fix is applied, then checked |
What Stays Open: Calls for the Owner, Maps to Redo
49 calls stay with the owner, grouped below with an example each. One job comes first: redo the oracle maps.
Hook and guards2 calls
Should a missing rules file deny every edit? The 20 ms hook ack and the trusted path are now decided.
The done gate8 calls
Should Decision 1 count a gate that never passes as failing? Run mutants on your repos’ checks too?
Asks and budgets3 calls
What makes an option irreversible? Which path patterns, and which case rules, does a lease use?
Extensions, the wiki5 calls
How fast an agent’s guess fades from the wiki. How a shape’s digest is computed is now decided.
The question card5 calls
Should each answer record which card you saw? Should tests get their own input source for the card?
Canvas, rendering, media22 calls
Compare after every patch, not only at the end? Ceilings for picture scores, rig numbers, the hash function.
From the research4 calls
IDs on every design sentence; agent-proposed checks qualified by mutants; a proposed-API tier; a version matrix.
Oracle maps firstredo
The pages tying canvas criteria to other projects’ tests fell behind the issue split: 88 problems in 172 maps, 185 issues with none, 27 old criteria to re‑check.
The Hook Runs on Every Step, So It Gets Under 10 ms
Version 0 holds DeepBuild to budgets. First deep-hook’s: one tool call, hub up (top) and down. Right: p95.
Six More Budgets, So DeepBuild Can Run All Day
The hub, the app, the record and the checks share your Mac with the agents all day. Each number is a target.
The Perf Gate Now: Gate the Middle, Show the Tail
So the perf gate now runs base and change 20 times each, taking turns. The middle run decides; the slow tail can’t fail.
20 runs a side
Base and change take turns, so both see the same load.
p50 decides
More than 50% worse than the merge base fails the change.
p95 is shown
Reported beside it, never gated: 20 runs are too few.
One reference Mac
A 16-inch MacBook Pro, M3 Pro. Elsewhere a result is only a reading.
CPU time
Wall time counts only against the preflight’s 5-minute cap.
Version 0 in Six Weeks: Five to Build, One to Use It
With its budgets set, DeepBuild’s own build plan: six weeks, each ending in an exit test. Week 6 is real use.
Spike
A short, throwaway trial that settles one choice first, like Part 3’s GPU handoff spike.
Exit test
What must work at the end of a week before the next one starts.
Dogfood
DeepBuild used on its own work: from week 3 it judges its own changes.
Under the gate
Agents build it from DeepBuild’s GitHub issues. A full PASS goes straight to main; nothing else lands.
Weeks 1 to 3: The Record, Then Asks, Then Verdicts
Top: what each week builds (yellow: spikes and dogfood). Bottom: the exit test that ends the week.
Record and hooks
a day of real sessions recorded, hook under 10 ms at p95
Asks and delivery
deep_aska CLI answer reaches an idle session; a repeat never reaches you
Gates and verdicts
blocks a seeded false “done”, passes the real fix
Weeks 4 to 6: See It, Add Codex, Then Use It for Real
Week 4 makes the work visible, week 5 adds Codex and drafted specs, week 6 is a week of real use.
See it
deep env up (a test environment, with leases)a journey video in the app; a taste call answered there reaches the agent
Codex and specs
every repo’s spec drafted and approved, none written by hand
Real use
used for a week; then Decision 1: keep going, narrow, or stop
Decision 1: Three Bars Decide Whether to Keep Going
After the owner’s week of real use, a rule written in advance decides. Every row must hold; a miss: narrow or stop.
Why Decision 1 Counts Only What the Owner’s Labels Confirm
The third bar counts “is it done?” messages. A program must recognize them, and a guess is not enough.
One Bad Merge Broke 688 Jobs: Send One Message, Not 688
Decision 1 tests one person’s week. The routing replay tests asks at scale on public history: 688 failures, one cause.
What the Replay Counts, and Why It Isn’t an A/B Test
Left: what else the same replay counts. Right: why a live trial couldn’t decide this at all.
Cut: Anything That Could Fake What You Trust
The plan’s cuts, by the rule each protects. First: nothing may fake the question card (Part 2) or a verdict.
unsafe Rust could bypass the declared reads the canvas relies onCut: Code in Documents, and Effects That Break Replay
Second: seek equals play (Part 3). Right: four ideas cut since a frame would depend on more than document and time.
Cut or Later: Outside the Scope, or a New Screen
Third: outside the scope, or a new screen. Red: cut, with the reason. Yellow: later, when a need or the owner asks.
Part 8: What’s Still Open
Can Part 7’s plan start? What the issues hold, R1’s longest chain, the risks nobody has measured, and the calls only the owner can make.
299,000 Words of Design, 29 Lines of Code
DeepBuild’s twelve days of design wrote a large, detailed plan; almost none is built. Next: the issues that hold the plan.
579 Open Issues, Three in Five of Them for R6
Counted live on GitHub on Oct 18. One square per open issue, colored by the release it belongs to.
R1’s Longest Chain: 18 Issues, Each Waiting on the Last
R1’s critical path, from the issues’ Depends on lines on Oct 17: the longest line where each waits for the one before.
What Can Run Beside R1’s Chain, and What Has Slack
Work off the chain can start early or run in parallel. Only the chain itself sets R1’s length.
Five Unmeasured Facts That R1’s Spikes Will Settle
Untested facts DeepBuild’s design rests on. Left to right: when a test settles each. Up: what breaks if wrong.
Five More That Wait for R2 to R6
The same chart for later releases: channels, the canvas, exports and games are built later, so tested later.
Six Calls Only the Owner Can Make
Questions only the owner may settle, besides the wall view. The last one has a default until the owner decides.
Scale Later (1 of 3): Hundreds of Agents, What Fits and What Doesn’t
If your agents move to the cloud by the hundreds, the record keeps up. What runs the work, and you, don’t.
Already fits
Doesn’t fit one machine
Scale Later (2 of 3): Four Things the Core Keeps From the Start
Small now, with a caller already: a host in every key, one way to run work, runs that declare their needs, and a fence.
Every lease and run names its host R1 #237
Leases on two hosts never overlap, and a pool such ascpu.slot counts per host.{host: local, kind: port, key: 5173}One host contract R1 #236
The supervisor ishost@1’s local implementation; SSH hosts (R3) and a cloud sandbox are more. Checks never learn where they ran.start(token, folder, env, leases) · signal · wait · facts
Each run says what it needs R1 #29
R1 places every run onlocal; later, a placement picks any host that fits from the same record.run 4f1 host: local needs: 2 cores, 3 GB, stack slot, 0 GPUs, ~90 s
A writer generation R2 #572
A restore, or moving the hub, raises it. A client that saw a newer one refuses a hub left behind.restore: generation 5 → 6 old laptop hub reports 5 → refused
Scale Later (3 of 3): Fleets and Teams, as Extensions
What comes later, built on the four seams, and what DeepBuild will not build.
Checks in cloud sandboxes
A host extension runs each check and its stack in a sandbox restored from a snapshot, paused while it waits, secrets kept outside. Placed by need; capacity follows the queue, not CPU.
Agents in the cloud
deep-hook reaches your hub over an authenticated link. Fast rules stay local, so a slow link never weakens a guard; each route’s timing is measured, never assumed.
Asks at fleet scale
A rate per person on Needs you. Past it, asks with one key share a card; the rest wait in deadline order and still take their safe default.
A team
One record per project, each with one writer; people see what their scope allows. Copies are never merged. Epic #11.
Not proposed
A scheduler or cluster of DeepBuild’s own, a shared database for one person’s record, or different people’s agents writing one record.
Where the lessons come from
How sandbox services, cluster managers and durable-execution engines grew: one writer, the host in every key, fence stale writers, place by need.
Then the Verdict Spine: One Line in the Chat, First
R1’s first exit: one stop travels the whole way and comes back as a verdict in the chat.
Where your agents show, not tell.
Docs: docs/technical-design.md and docs/canvas-primitives.md · the plan is the issues and milestones.