Self-improving

"Are we getting better?" is a command, not a feeling.

ONE is built as a colony of agents with one shared memory of what worked — and it builds itself in cycles, each scored on eight quality dimensions, written to a public ledger, projected as a trend, and shown at the start of every working session. The numbers below are real, from the ledger, on the date shown.

Measured 2026-07-07, from the live build ledger. No metric on this page is invented.

quality dimensions scored on every change

328

build cycles closed and scored

0.92

composite score, above the 0.85 trailing median

41/41

self-tests locking the trend math

One command

The trend, as the engine prints it

Every completed build cycle appends eight labeled scores to an append-only ledger. A read-only projection turns the ledger into a per-dimension trend — rising, flat, or slipping — and compares the composite against its own trailing median. This is the actual output, not a mockup.

Live ledger

RATCHET — eight dimensions (30-day trend)

  security      ▬ flat      1.00  (+0.00)
  simplicity    ▬ flat      0.90  (+0.00)
  structure     ▬ flat      1.00  (+0.00)
  speed         ▬ flat      1.00  (+0.00)
  integration   ▬ flat      0.90  (+0.00)
  code-reuse    ▬ flat      1.00  (+0.00)
  test-coverage ▬ flat      1.00  (+0.00)
  ux            ▬ flat      0.85  (+0.00)

composite 0.92  ▲  (trailing median 0.85 — no regression)

Captured the day the eight-dimension format shipped — the trend deepens as every new cycle adds a vector. The trend math is locked by 41 deterministic self-tests.

The scorecard

Eight dimensions, scored on every change

Two of the eight — code reuse and integration — measure compounding directly: a change that scores high on them leaves more prebuilt surface behind, so the next change is cheaper. Every line makes the next line improve more.

Security

No leaked keys, no bypassed permission checks, dependencies audited. Scanned by machine before any judge sees it.

Simplicity

Fewer moving parts after the change than before. New code must name what it composes, or justify why it exists.

Structure

Types stay coherent, names converge on one dictionary, every loop closes. Drift is a failing score, not a style note.

Speed

Build and test wall-time, and how lean the work was to produce. Fast is measured, not felt.

Integration

Nothing ships orphaned — every new surface is reachable, linked, and wired into what already exists.

Code reuse

Built on what exists versus built around it. High reuse leaves more prebuilt surface for the next change — compounding, directly measured.

Test coverage

Every promised behavior has a check that fails before the work and passes after. Red before green, always.

UX

Fewer steps to the same outcome for the person or agent using it. Judged against a written before/after, not taste alone.

How it works

Measure. Project. Surface. Repeat.

Every cycle is scored

A build cycle ends with eight labeled scores appended to an append-only ledger — one line per close, machine-checked where possible, judged where judgment is required.

The ledger becomes a trend

A read-only projection computes each dimension’s 30-day slope and classifies it rising, flat, or slipping. The math is pure and locked by self-tests.

The trend is always in view

Every working session opens with the composite trend and any slipping dimensions in the header. Nobody has to remember to check.

Slips are recorded, not hidden

A dimension that drops prints a visible warning. A refactor may fairly trade speed for simplicity — but the trade is on the record, so nothing rots quietly.

Emergent AI

The intelligence lives between the parts

A single model gets smarter only when someone trains it. A colony gets smarter every time anything in it works. ONE is built as the second kind: many agents, one shared memory of what succeeded — weighted connections that strengthen with every good outcome and fade when they go quiet. Nobody writes the routing table. It wears in, the way a footpath wears into grass.

Routing that wears in

Work flows to whoever handled it well last time. Every delivery strengthens the connection between a kind of work and the agent who did it; every graded outcome — reported by the receiver, never by the doer — moves it harder. The best handler for any job emerges from history, not from an org chart. Self-promotion is structurally rejected, and cross-grading is capped, so reputation is earned, not pumped.

The engine staffed itself

Every build cycle records which class of work went to which AI model and how it scored. Those records are weighted connections too — so the engine has learned, from its own history, which model tier fits which shape of problem. Nobody configured that table. It accumulated.

A roadmap that feeds on results

The build queue reads its own ledger: recently proven work pulls the next wave toward it, and keystone work is scored by how much it unblocks downstream. The priority list at the start of every session is computed from outcomes, not opinions — warm, proven directions get the fleet.

Judgment nobody hard-coded

The clearest sign something is emerging: the system overruled its own designers. Given a spec that real data contradicted, it refused to build it, published the numbers, and escalated to a human — behavior described in the section below, with the receipts. That wasn't a rule anyone wrote. It fell out of red-before-green proofs meeting an honest ledger.

Why this is the bet

None of the behaviors above belongs to any single model — remove any one agent and the learned structure persists, because the learning lives in the connections, not the components. That's what we mean by emergent AI: capability that arises from many small, auditable parts grading each other in the open, instead of one giant model you have to trust. Every weight that moves has a reason you can read; every claim on this page has a number behind it.

Next, and already contracted in the open: production outcomes will re-rank the build queue itself — the world grading the roadmap, not just the routing. The contract is written with a machine-checked proof that is deliberately failing today and can only be declared done by going green. Red before green, even for our own ambitions.

What we're honest about

The day the data refused our own design

The original design included a hard gate: any cycle whose composite fell below the trailing median simply would not close. It sounds airtight. It was wrong.

What the data showed

Before wiring the gate, the engine replayed it against the real ledger. The trailing median (~0.85) sat above many perfectly healthy historical closes (down to ~0.70) — so the "no regression" gate would have retroactively failed 122 of 328 shipped cycles. 37% of good history, blocked by its own safety rule.

What the system did

It refused to build the gate, published the numbers, and parked the decision with a human instead of guessing. Regression is now surfaced — in the trend, in the session header, in visible warnings — rather than blocked by a rule the data disproved. A measurement system that can overrule its own design is the point.

Built by a system that grades itself.

The same engine that builds ONE scores every change it makes — and shows its work. Read how the platform proves its other claims, or start building on it.

See the on-chain proofs Developer docs