Cosmon — A System That Builds Itself

What 67 days of agent-orchestrated development measure — and the one bit that matters.

For most of software’s history, a person drove every step in the development cycle. Cosmon is an experiment in handing a growing share of its own construction to the agents it orchestrates — and then measuring, honestly, how far that actually goes.

It is not a product announcement. It is a report on a system that has been building itself, in the open, for sixty-seven days, run by one operator. Below are the numbers, with their caveats, and the single idea underneath all of them.

Four principles, one of them load-bearing

Cosmon rests on four founding principles. Three are consequences of the first.

It from Bit (self-reference). Every tool must be able to operate on itself. Cosmon orchestrates its own development: the command that launches a unit of work can be pointed at the code that constructs it. A feature that cannot eat its own output has not earned its place.
Transport / Cognition. The framework routes; the agent thinks. Cosmon never reasons — it spawns, monitors, reconciles, persists. Models evolve; the transport layer endures.
Intentions, not ownership. Desired state is written; observed state is derived from reality; a reconciliation loop drives the gap to zero. The blueprint is not a photograph.
Minimum action. Every unit of computation has a real cost — economic, environmental. Don’t spawn six agents when three suffice; don’t use the large model where the small one works. Tend toward equilibrium.

The first principle is the one to watch, because it is exactly the dynamic the rest of the field is now naming out loud: a system that increasingly builds itself. Cosmon’s bet is that this is only safe if it is bounded (minimum action resists the runaway loop), non-cognitive at the seam (the self-building substrate does not itself think), and measured (no claim survives that the running system contradicts).

The honest data (67 days, one operator)

The point of the self-reference principle is that it is falsifiable. Here is what it measures, as of 7 June 2026:

96% of merges entered the codebase through cosmon’s own orchestration system — 1,132 of 1,174 merges came in on agent-orchestrated branches, not by hand. This is the self-reference made concrete: the system’s own machinery is how the system grows.
6,322 tests. ~373,000 lines of Rust (excluding build artifacts and worktrees).
10,418 commits in 67 days, one operator directing.
Agent authorship: 1,483 commits carry an explicit agent co-authorship trailer. This under-counts — the trailer is not emitted on every agent-authored commit, so true agent authorship is higher. (A defined-denominator measurement of the share of agent-authored lines is in progress; this draft will not publish a figure it cannot yet verify.)

The caveats are not a disclaimer; they are the product. The intended reader is a scientist, and for a scientist a number without its method is noise.

The method is Galilean

Cosmon borrows its vocabulary from physics, and with it the debt: a beautiful metaphor that does not survive contact with observation is decoration, not architecture. Observe the running system; attach numbers; propose the simplest mechanism that compresses them; derive a prediction the model has not yet been tested against; if it fails, update the model — not the data.

“It doesn’t matter how beautiful your theory is… If it doesn’t agree with experiment, it’s wrong.” — R. Feynman

Every claim above is subject to that test. The phase-transition language, the “self-building” language — each is a prediction with a measurable threshold, or it is struck.

The one bit that matters: verify

There is a reason this report arrives now. The field’s conversation has converged on a single hard problem — not capability, but verification: when an agent acts and a human reviews, what is the smallest record that makes the act checkable by anyone, with no one to trust?

Cosmon answers it structurally, in the code, not in a policy: the events are the system (the state is a projection of an append-only, hash-chained event log), and time is anchored independently of the operator. The bit “what was desired” and the bit “what was observed” are kept separate, with a deliberate one-tick lag between writing and reading — which is also where the safety margin lives.

This is the quiet inversion. The hardest thing to build at the scale of the whole field — a verification regime no actor can fake — is the thing a small, self-referential system can have by construction, because it was instrumented from the first commit.

What is not proven

Honesty cuts both ways. Cosmon does not yet demonstrate research judgment — choosing which problems are worth the compute remains the operator’s. And there is a live, falsifiable experiment now underway: cosmon has only ever run well in its cradle, one operator’s machine. A first instance has just been deployed in a hardened cloud environment, with an encrypted core, to test whether it works as well outside that cradle. We do not yet know that it does. We will report what we find — including if it fails.

That is the whole posture: a system that builds itself, measured against the discipline of someone who would rather be proven wrong early than admired late.

Running now, public later — four reasons

The system runs in production today. The public source release comes later — and the gap is deliberate, not a delay. Four engineering reasons hold the door:

The working trees still carry private references. The event log is internally honest, but the trees reference third parties and unpublished work. Opening means a mechanical, auditable scrub of those references first — a reviewable pass over the tree, not a rewrite of the history. Until that pass is done and checked, the repository is not ours alone to publish.
The cloud instance is still under test. The hardened-cloud deployment is days old. Publishing the source now would invite people to run something we have not yet verified runs outside its cradle. We open after we know, not before — the same rule we apply to every number in this report.
The measurement is not closed. The agent-authorship denominator is still being defined. The discipline that keeps an unverifiable figure out of the prose keeps an unverifiable codebase claim out of the release: we ship what we can stand behind, when we can stand behind it.
Opening is itself a unit of work, and it should eat its own output. By the first principle, the public release is not an exception to cosmon — it is a job cosmon should run on itself: gated, hash-chained, timestamped like any other merge. We are letting the system build its own door. That takes one more turn of the same loop, and we would rather it be honest than fast.

None of these is a moat. Each is a checkable precondition with an owner and a finish line. When they are met, the source opens.

Cosmon is an open-source framework; the source will be released under AGPL. This is a report, not a manifesto; the numbers are dated 2026-06-07 and will be re-stated as the system grows.