The organisation's only active project

ai-os — an agent‑based operating system.

Agents today are applications. This is the argument that they should be an operating system — and that the difference is not branding, but three abstractions nobody has built yet.

An OS earns the name when it owns how work survives interruption, how state is addressed, and how a person perceives and steers the whole machine. QM already solves the hard part underneath: a real multi-tenant harness with scoped identity, permissions, sandboxes and audit. ai-os is the layer above it.

Try the desk → Run it for real Repository

ai-flowsai-ui ai-storageai-base

Four questions today's agents cannot answer

What is this agent working on? A list of sessions. A session is a conversation, not a unit of work — no declared goal, no success condition, nothing that survives compaction.
What does it know, and why? A file. One flat namespace per scope, capped, dropping the oldest fact when it overflows.
What is it looking at? A chat log — the right metaphor for a conversation, the wrong one for work spanning weeks.
Can I branch this and rejoin it? You can fork. Nothing records that it forked, so nothing can ever diff or merge it.

Four pillars

ai-flows

What if the unit of work outlived the conversation?

Runs. A flow is a declared, persisted, resumable object with a goal, a shape, a state and a lineage. Agents and their sub-agents are markdown files; a declared tree executes as real work. A flow started by one process is finished by another, after a restart and after context compaction.

ai-ui

What if the interface were the state, not the transcript?

Runs. A desk: flows are documents, agents are cubes that stack on them. Drag a cube onto a document and that agent gets a step in that flow. The system composes the arrangement from the flow's state and never re-arranges what you moved.

ai-storage

What if memory had an address space?

Four levels — system, user, project, flow — with different lifetimes. Flow memory is expected to die. Promotion between levels is explicit, recorded and reversible. The first piece of it runs: a project knowledge base an 8,000-token window can navigate. A flat file of the same material stops fitting at 16 units; the index is still at 4,523 of 8,000 tokens at 2,000 notes — and where it does run out, at ~15,000, is written down rather than left to be discovered.

ai-base

What if we did not rebuild the part that works?

QM, vendored as a subtree and pulled weekly. Identity, scopes, sandboxes, policy, audit and six model harnesses. We did not write it and we are not rewriting it.

Where this actually is

Three pillars run. ai-base is vendored and runs. ai-flows runs — the flow engine, a signed HTTP API, multi-agent composition from markdown-declared trees, and the measurement harness below. ai-ui runs — the desk pictured here. 487 tests of our own, on top of the 3,768 ai-base carries from upstream. Memory is now agents rather than a store — an archivist that decides what one unit of a document is, an indexer that writes one note per unit against an index that has to keep fitting, a reconciler, a librarian and a coverage auditor, all of them markdown files. Every decision is an agent; every mechanic is code. The rest of ai-storage is still specified and not implemented. Nothing on this page describes running software unless it says so.

A desk: two flows as documents with agent cubes stacked on them, and a panel showing a flow digest, a menu of proposed actions with their cost, and an answer read out of the flow's trace — Open the desk and use it → — press Play and it walks itself through the whole vocabulary, or take over at any point: a real gesture stops the tour where it stands. Every beat is the real client receiving the events a hand produces, never a recording, so if the desk breaks the tour breaks. It is the real interface with a fake backend behind it, so nothing is installed and nothing is spent. Drag an agent cube onto a document and it gets a step; press Advance and watch the step run; open the Trace face and see what each agent actually returned. Try dropping ReviewAgent on the ledger flow: it answers "Looks fine to me", the flow reports 3/3 done and green — and the trace flags that the step carried nothing forward. That is the finding the whole system exists to make visible.

The agents are alive on it now: each one is a creature that blinks while it waits, narrows its eyes while it runs, and says which step it is on. Give an agent work in a second document and it splits in two; take the work away and the extra one walks back into the first. And a companion, Cubi — the same creature at twice the size — watches what you touch, walks over to whichever agent you clicked, and asks it; the agent answers for itself, in the first person, out of its own record. When a step finishes, watch the result travel to the next agent: it arrives as a green square, or it falls short and drops on the floor in red, which is that flow's own trace saying the step carried nothing.

Then switch the scope to group:signal-lab — the same desk, on numbers. Two flows hunt a 5 Hz tone under a mains hum, with the same six agents and the same six steps, and both are green from end to end. One found the tone at bin 5; the other lost it at step 2, to a fixed-point conversion with the scale entered wrong, and answers "strongest component: bin 0, magnitude 0.00" with exactly the same confidence. Nothing in the interface knows what a Fourier transform is: the same digest, the same trace and the same "carried nothing forward" flag find it, and the evidence is a flatline you can see from across the room.

On the right, Documents — the surfaces that change while you are looking at them. Four kinds, and the two marks that matter: a dot when something is writing to it with nobody waiting, and whether you may write back. A flow being run by agents is read-only and alive; the project chat is yours; the log of what the agents said is a record and nobody types into it. Read-only is a property of the document, not of the panel. Wake its optional brain and a small language model loads into your own browser to answer freely, with everything it invents marked in red against the trace it was given.

A document is a flow; a cube is an agent; a cube resting on a document means that agent has work in that flow. Dropping one there is not a view change — it appends a real step, the same instruction composing an agent tree would have written. Positions persist per scope, and the system never re-arranges what you moved.

The panel on the right is the part a GUI could not have done. The digest states how many attempts it stands for and over what window, because a flow changes faster than anyone looks at it and a summary that drops an attempt reads exactly like a clean one. The menu is derived from this flow's state rather than fixed, and every entry carries the evidence that produced it and says whether pressing it spends. The answer is read out of the trace and never the goal — the goal is what somebody meant to happen, and it reads like an answer even when the work was never done. Asking with no evidence recorded costs nothing: it says so instead of buying a turn to tell you there is nothing there. What this does not establish is whether it helps. Its own falsification is a stopwatch — a person, a three-day-old flow they did not run, desk against transcript — and that has not been run.

Every scope level, its members and the agents each defines — Organisation, projects, groups and individuals — with each scope's roster and its agent tree, from a live instance. The interface borrows its vocabulary from System 7: one colour per kind of thing, so what you are looking at is legible before you read it. AnomalyScanner is struck through because it is declared in an agent's markdown and has no file — a declared name is a claim, a file is a fact.

Each pillar ships with the measurement that would show it is not worth building, written before the code. Two have now come back and neither flattered us. A flow does survive what a plain session loses — proven by starting one in one process and finishing it in another, on two harnesses. And the question of whether adding a reviewer to an agent tree helps came back unmeasurable: across four attempts the producer was already correct, so a review stage had nothing to add.

That second result is the one worth reading. It is the shape of Google's g-AMIE study, where physician oversight of an agent improved 6.7% of cases and reduced quality in 21.7% — oversight adding least where the output was already strong. Our first run appeared to reproduce it, reporting a reviewer that damaged a correct answer. It was an artefact of a check that scored “The answer is 24.” as wrong, and retracting it invalidated four other numbers. All of it is written up rather than deleted, because a finding that was wrong and the reason it looked right is the most useful record we can keep.

The predecessor of this project shipped eighteen thousand lines describing five subsystems and three test functions — an architecture written down and never pinned to anything that could contradict it. This is the correction.

Twenty-six frozen experiments, 2025 – 2026.

Agent memory, self-modification, interpretability and constrained decoding — each labelled by how much evidence stood behind it, including the ones where the evidence went against us. Kept because they are still true, not because they are maintained.