Same rule for new apps
The Apps folder is open-ended.
Seven built-ins, plus every connector that declares an app URL.
The seven
Brain, Control deck, Memory Graph, Connectors, Costs, Builds and About Board OS.
Living Code OS is a company brain that is also an operating board. The operating system part is not a skin over a chat box; it is a doctrine written into the code. Operating system here means a shell for this product's own features, a window manager, a dock and apps, not a replacement for the computer it runs in.
Whoever asks, by whatever channel, searches the same memory and reads the same originals.
Every recording, email, file, text and call goes in through one door, and every question comes out through one door.
A single ingestion function writes the original whole to R2, registers one row in D1, cuts the text into 1,100-character chunks with 150 of overlap, embeds each with bge-m3 on Workers AI (1,024 dimensions) into Vectorize, and has Llama 3.3 70B extract people, companies, projects and topics. Everything except the original is derived and can be rebuilt.
A single retrieval function fires four legs in parallel, title, vector, BM25 full-text and entity anchor, filters each by room access, and fuses them with reciprocal rank fusion (constant 60; weighted 1.0 vector, 0.9 full-text, 0.85 title, 0.8 anchor). An agent ranks on 700-character snippets, then reads the original in 14,000-character pages. The board, a phone line and a partner's MCP client all call that one function.
A new feature does not get a page. It registers with the window manager and files its events into the notification center like everything else.
Open anything on the board and it tiles into free space, remembers its size, minimizes to a chip, and reports to one notification center. Code enforces that, not convention.
Every panel registers with one window manager, which fronts it, attaches resize grips (minimum 300 by 160 pixels, sizes remembered per window), and watches the hidden attribute so the registry stays truthful. New windows tile rather than cascade: the placer walks a 28-pixel grid and takes the first slot that clears a 14-pixel pad; if nothing fits it narrows the window to a column of at least 360 pixels, then stacks. A window you dragged by hand is never re-tiled.
Minimize shrinks the panel toward the dock at 4 percent scale and leaves a chip. Below 768 pixels the dock becomes a right-edge rail: swipe to summon it, flick right to throw an app off screen.
Seven built-ins, plus every connector that declares an app URL.
Brain, Control deck, Memory Graph, Connectors, Costs, Builds and About Board OS.
Packets become category-hued cards with per-category mutes.
In a settings table on the server. An agent can flip one with set_ui_setting, which files a packet so every open board applies it.
The Archive keeps the newest sixty, with restore, open and download.
Model-authored HTML in an iframe sandboxed to scripts only, capped at 90,000 characters.
The constellation behind every window is the graph itself, read live from two tables. Not a picture of the data. The data.
Every person, company, project and topic hangs in a 3D field behind the windows, brighter the more recently it was seen. When the resident agent talks, that field becomes its face.
The graph page reads exactly two tables, entities and edges: the 800 most-mentioned entities by default, up to 25,000. Every entity is a bloomed sphere. Hue is kind: person blue, company green, project amber, topic violet. Brightness is recency, a glow from 0.55 to 1.0 over 180 days. Size is mention count, clamped to 24. A node seen within the last six minutes, and new to this session, streaks in as a meteor.
Search does not happen in the scene; dossiers, events and community briefs serve answer time and never reach the display. The scene is steered instead. When an agent calls show_on_graph, a focus packet parks the camera 130 units beyond the node over 1.4 seconds, and a reference in a brief draws a glowing thread from the card to the node. The cinematic tour is camera-only; node positions are never touched.
When the resident agent speaks (Jeffery on this deployment; every deployment names its own), the page takes 18,030 nodes, 17,700 for a baked head mesh plus 330 for lips, irises and eyelids, and eases each toward a point in face space. A jaw drops up to 0.16 face units with the live audio level; blinks arrive 2.8 to 6.6 seconds apart; gaze drifts. When the conversation ends, each face node gets a radial kick of 26 to 45 units and the face detonates back into the constellation.
Said plainly: the lip sync is amplitude only. A 128-bin FFT sums bins 2 through 39 into a level between 0 and 1, posted every animation frame. There are no visemes and no separate listening state. That is what it is.
Two boards side by side, or a board and a phone, show the same state within a network round trip. No reload.
Approve a card on your phone and it leaves the tray on the desk. Ask the agent to focus the graph and it swings on every screen. The board is pushed, not polled.
The client opens one WebSocket to the board Durable Object and reconnects with backoff from one to fifteen seconds. Chat turns, settings, card state, focus, phone events, file events and build logs are all packets. Every surface files them into that one object, which assigns a sequence number, journals to D1, and broadcasts to every socket.
Rendering is differential, keyed on version, last run and flip state, so unchanged cards never flash. A show-card packet slides the card in from the nearest edge; a focus packet posts to the graph; a settings packet applies settings.
A session is disposable. A colleague has a name, a directive you can edit live, a budget, and a record of every run.
The Hive lists workers the way a team directory lists people: by name, with a state dot, a chat column, their routines, and a log of what they did. You can change a worker's instructions before its next run, without a deploy.
Each fleet worker is its own Cloudflare Worker, born from a spec, with its own cron. It is two documents: code, and a directive row edited live in the Hive and re-read on every wake. Each run senses, reasons with one gateway call, acts by filing one packet, and records a flight-recorder row with a JSON trace and its cost, always, in a finally block.
A gateway holds the API key; workers never do. It compares today's spend to the daily budget, fifty cents by default, and returns 429 when it is spent. Budget means a cost ceiling, not financial authority: it pays for model calls and approves nothing.
The resident agent is the same idea with a bigger belt: about eighty tools, a written doctrine, and the foreman's role in the Hive.
The line between reading and acting is not a setting. It is the shape of the code.
Agents search, summarize, draft, propose and file. Sending an email, moving a meeting, starting a paid build, birthing a worker, or merging to production lands on a tray as a card and waits for a person.
Every surface that wants a real-world effect calls one function that inserts a pending row with the exact JSON payload that will run and journals a request packet. Nothing executes until a resolve function runs with approval, reachable only from the board tray, the Control deck's approve tool, or the paired messaging chat. Resolve refuses a second resolution and applies tray edits into the stored parameters. What is in the fields at approval is what runs.
Above the money line of twenty-five dollars, approving demands a PIN, a second factor layered on scope, so a leaked operator key can work the tray but cannot spend.
If the executor throws, the action is marked failed with the error text and the board raises an interrupting card: "Approved, but it did NOT execute." That card exists because three approved ships once failed silently. The same lesson is a written line in the resident agent's doctrine: never report an action you did not see succeed.
Streamed build sessions, a weekly changelog, a demo, and a ledger of what the week cost.
Read the build log →The plan is to build the rest of this in front of people: streamed sessions, several developers, and a weekly publish of a changelog, a demo, and a ledger of what the week cost.
The sessions worth watching are the ones where the system builds itself. The Shipwright building a feature: plan, write the files, verify them in a sandbox, pull request to staging, CI, a browser test judged by a different model lineage, then a merge request for a person. Production merges are never automated. A worker born in the Foundry, every step streamed to the Hive. A machine paired through the Hand. The face speaking for the first time.
The work splits along the seams this site describes: memory, the shell and apps, the graph and avatar, the fleet, the communication surfaces, the Hand, and the platform plumbing. Every model call is already metered into one table with its cost, so the weekly ledger is not a new thing to build.
The operating system metaphor is literal in the code, not decorative.
Leave an address. When there is something to hand you, you will know before anyone.