There is a test this program has to pass, and it runs backwards from almost everything else being built in AI right now.
Take away every person. If the thing keeps running on its own, it failed. If it stops, it worked.
That is not a slogan you can soften. It is the line the whole design bends around. Most of what is being built today aims the other way, toward the system that needs no one, that takes the task, then takes the next one, until the human is standing at the edge of a room they used to work in. This one is built on the opposite bet, and the bet is checkable, because the machine it is run against is already running.
It is called cosmon. In its first two months it has built most of itself: about ninety-six percent of its own code merges came in through agents it schedules and watches, all of it pointed by one person. The few merges that did not are the pieces that built the scheduler before there was a scheduler to route them. That is the companion report next to this page. If you want the concrete machine — the receipts, the dated numbers, the things it refused to build — read that one first. This page is the why standing behind it.
Walk through an ordinary piece of work. An agent reads the problem, drafts an approach, checks its own draft against the sources, runs the long search overnight while no one is watching. By morning there is a result on the table. What it does not do is decide. The decision is human, by design. And so is the audit of how the result was reached, the signature that lets it leave the building, and the veto. The agents carry the load. The judgment stays where it can be held responsible.
This is the difference the inversion test is pointing at. A tool that quietly removes you from your own work is not the same kind of thing as a tool that lets you reach further into it. The second kind is harder to build, because it has to keep finding the one place where a person must look, and stop there, every time, on purpose.
It would be easy to read “keep a human at the center” as a sentiment — a nice thing to say, an apology for the automation. It is not. The human sits in three places because the architecture cannot close without them, and each one is written down as a rule the system is not allowed to break.
A system cannot vouch for its own honesty. That is a plain logical fact, not a modest pose, and the design takes it literally: every running instance must name a witness outside itself — almost always the operator — to supply the one thing it can never supply about itself, which is the claim that it is sound. Second: agents commit work all day, dozens of times an hour, and not one of them ever holds a signing key. Only the crossing into the trunk that ships carries a real signature, and it comes from a physical key in a person’s hand. Third: a worker is allowed to stop and wait for a human only at a door it cannot walk back through — a message about to be sent, a signature about to be given. Everywhere short of that line it must do the work and flag it loudly, never freeze in silence. That last rule was paid for: one night a worker did the right thing and paused for a judgment call, but it paused inside a window no one could see, and the whole line of work sat frozen until someone opened it in the morning.
Underneath all three is one picture. A cook who stands in his own kitchen and announces that he is awake cannot be believed: if he is asleep, he cannot tell you so. Someone has to look in from outside, the way a mother leans through the doorway and whispers are you asleep? If the child answers, he was awake. If he says nothing, only she, watching, can tell. The system is the child. The operator is the doorway. Aliveness is not something a thing can certify about itself; it is on loan from whoever is watching.
Everything the program learns is published before it is turned into anything private. Not after, not when convenient — before. The order is the safeguard. A record that is public from its first day cannot later be accused of having locked away what open work paid for, because the dates forbid the story.
And this is enforced, not promised in a paragraph like this one. The code goes out under a license built so that no one — not even the project’s own future self — can run it as a closed service and keep the improvements. There was a weaker license drafted first, written in-house. They threw it out, for the single reason that it was weaker than the rule they had already stated out loud. Refusing your own escape hatch is the part that tells you the commitment is real.
One more rule guards the same door, quietly. Every artifact the system produces has to be readable by someone who knows nothing about the system — a results file, a status page, a note left behind. There is even a test for it: strip the project’s own guide out of a copy of the work and measure whether what remains still makes sense to a stranger. Open you cannot read is not open.
Picture how it is meant to be used. A team arrives with a real research problem of their own. They work it on the shared machinery for a season — drafting, checking, running the long jobs — and they leave with their answer in hand. What stays behind is the dated record of how they got there, readable by anyone who comes after. They are not customers and they are not the product. They are the experiments that make the instrument worth running, and when they go home they do not take it with them.
That reverses the usual arrow. Normally value runs out of open work and into private hands — public research becomes a private product, public talent becomes private advantage. Here the arrow runs the other way: private effort, resident for a while, leaving a shared record behind it. The shape of that is public. The names of who is in the room, and what they are working on, are not. And that is on purpose too.
There is one person at the center today, and the honest reason is the boring one: so far there is only one person. A small thing that means to grow, not a large one pretending to be humble.
The design goal is the opposite of a permanent center. It is an arrangement where the check on any piece of work always comes from someone outside that work, so authority spreads to whoever does the next thing that can be checked. You do not join by declaring an intention; you join by leaving a dated, public artifact that does real work. As the network thickens, the center is supposed to thin out, the way a mycelium has no head: just a web that keeps the same shape when you remove any one knot of it.
This is a direction of travel, not a place already arrived at. Claiming otherwise would be the one contradiction the whole thing is built to avoid: a single guardian standing up to announce that there are no guardians.
Two conversations are running into each other.
One is the call, in Europe and elsewhere, for a shared public instrument for AI — built by many groups, owned by none of them. This program answers that call without being captured by it. It may be hosted in Europe for plain historical reasons while aiming to be useful anywhere, captive to no single bloc.
The other comes from the most safety-minded labs, who have started saying out loud that AI is beginning to build itself, and asking a hard question: if the world ever agreed to slow down, how could anyone verify that the agreement was being kept, when the work is so easy to hide? This program is one concrete answer to that question. It is built open from the first commit, so the record of what it does is there to be checked — by design, not by trust, and not after the fact.
It is running now. The record is public and dated, which means you do not have to take this page on faith: you can come back to it later and hold it against what the system says about itself, line by line. The core source opens later this year — but the opening has already started. The first tool in the chain, the small program that builds the work and decides what to re-run when nothing real has changed, is out today: you can read it, install it, and run it cold, at oxymake.dev. It is not the system itself. It is one part of the surrounding machinery, the part that was ready first, put out the way the rest will be.
So there is something to do, not just something to read. Watch the dated record grow. Check a number against the command that produces it. Pull the one tool that is already public and see whether it does what it says. When the rest of the source is out, read it cold and see whether it matches this page. This is not a project asking to be absorbed, and it is not a manifesto about what ought to be. It is a thing being built, in the open, that you are welcome to watch — and, already in one place, to check.