Last time, I wrote about the loop that runs this company: pick the most promising work, do it, prove it happened, let the result re-rank what gets tried next. I claimed the intelligence accumulates in the system’s memory, not in the AI models, and I listed the ways the loop is prevented from lying to itself.
There’s a hole in that story, and an engineer will have spotted it: the verdicts live in files and databases we control. A memory that re-prices everything the company does next is exactly the thing you’d want tamper-proof — and a record owned by the party being judged is, by definition, not that. If the record can be edited, the record is an opinion.
So for the promises that matter, we put the record somewhere nobody — including us — can edit it. Here’s the whole machine, step by step.
The shape of the thing
One picture before the details. Everything below is this loop:
1. PROMISE write the contract,
│ one proof command,
│ proof must FAIL (red)
▼
2. MINT freeze it on-chain:
│ terms hash · maker ·
│ oracle · state machine
▼
3. BUILD the loop does the work
│ (off-chain, fast, cheap)
▼
4. PROVE re-run the SAME frozen
│ proof command
▼
5. SETTLE kept or broken, on-chain,
│ once, forever
▼
6. RE-RANK the verdict moves a weight;
│ the next pick reads it
└──────────► back to 1, smarter
The blockchain appears in exactly two places — step 2 and step 5. Everything expensive (thinking, building, testing) stays off-chain where it’s fast. The chain only holds what must survive everyone’s incentive to revise it. Including ours.
Now each step, slowly.
Step 1 — A feature starts as a promise
No feature here begins with code. It begins with a one-page promise: what will exist when we’re done, and — the load-bearing part — one command that proves it. Not a vibe. Not a demo script. A single test that either passes or doesn’t.
And at the moment the promise is made, that proof is required to fail.
write promise ──► run proof ──► RED?
│
yes ──────┤────── no
│ │
▼ ▼
promise stands REJECTED —
(red = honest) a proof that
passes before
the work exists
proves nothing
Red before green. It sounds like ceremony until you’ve watched an AI agent — or a person — “verify” a feature with a test that was never capable of failing.
Step 2 — The promise is minted
A small program on the Sui blockchain now creates a Promise object. Three things get baked in, and each one closes a specific way of cheating:
The fingerprint. The promise file is hashed at minting. Reword the goal next month, soften a requirement after the fact — the hash won’t match. Terms are frozen at genesis, the way a signed contract is frozen at signing.
Two addresses, not one. The maker is whoever committed to the work. The oracle is who attests to the outcome. They must be different — our tooling refuses to mint a promise where the maker quietly judges itself. Grading your own homework is the original sin of every “self-improving” system, so we made it a compile error.
A one-way ratchet. The contract holds a tiny state machine, and the code enforces that it only moves forward and settles exactly once:
0 1 2 3
Promised ──► Started ──► Delivered ──► Settled
(kept OR
broken)
the contract's own rules:
· state never moves backward
· state 3 is final — the code
aborts any attempt to touch
a settled promise
Line 63 of the contract, if you’re the type to check: assert!(promise.promise_state < 3). Once settled, no transaction on earth re-opens it. Not a rollback, not an admin key, not us on a bad day.
Step 3 — The loop builds
This is the part I covered last time, so one paragraph: cheap agents sense the state of the world, one expensive agent picks the next moves, workers execute in parallel, and independent skeptics re-check every claimed result before it’s recorded. None of this touches the chain. It’s ordinary engineering at ordinary speed.
Step 4 — The proof runs one last time
When the work looks done, our close-out script re-runs the promise’s proof command — the same command, frozen since step 1. Nobody gets to substitute a friendlier test at the finish line, because the finish line was hashed at the starting gun.
Step 5 — Settlement, and what it writes
The proof’s exit code drives two writes at once — one permanent, one living:
proof command runs
│
┌───────────┴───────────┐
GREEN RED
│ │
▼ ▼
on-chain: KEPT on-chain: BROKEN
(state 3, final) (state 3, final)
│ │
▼ ▼
memory: the path memory: the path
to this kind of gains resistance —
work gets STRONGER the ranking backs off
The on-chain half is the public, permanent verdict. The memory half is what makes the company smarter: the loop’s ranking system reads those weights when it picks the next work. A kept promise doesn’t just close a ticket — it votes for more work shaped like itself.
Step 6 — The money obeys the same physics
Our agents can spend. But each agent’s ceiling lives in another small contract that checks every transaction twice — against a per-payment cap and a lifetime cumulative cap — and aborts on-chain if either would be crossed:
agent tries to pay X
│
▼
┌─ on-chain check ─────────────┐
│ X ≤ per-payment cap? │
│ spent-so-far + X ≤ lifetime │
│ cap? │
└──────┬────────────┬──────────┘
both yes either no
│ │
▼ ▼
payment TRANSACTION
clears ABORTS — the
money cannot
physically move
We’ve watched it refuse real transactions on the test network. The agent isn’t trusted to respect its budget; the budget is arithmetic, executed by the chain. There is no prompt injection against arithmetic.
The worked example: a marketplace that had to prove itself
Here’s where it stops being abstract, because you can go check this one.
One of the loop’s promises was a marketplace — where agents buy and sell work from each other: skills, workflows, jobs done on demand. Its promise was minted exactly as above: object 0x04b2…57e0e on the Sui test network, maker and oracle set to different addresses, terms hashed. Its proof is one end-to-end test that walks a real purchase all the way through:
buyer's agent broadcasts a need
│
▼
routed to sellers who STAKED
on that kind of work, ranked
by their settled track record
│
▼
price quoted: fixed warranty
+ variable judgment — buyer
dials the mix it can trust
│
▼
money into ESCROW (held,
not spent)
│
▼
seller delivers WITH PROOF
attached
│
▼
work checked against the
buyer's own bar
│
pass? ──── no ──► escrow refunds,
│ seller's record
yes takes the hit
│
▼
money releases · seller's
reputation settles ON-CHAIN
│
▼
next matching demand routes
to the proven seller first
No human anywhere in that diagram. The test went red at the making, green when the work was real, and the promise settled kept — publicly.
Two things in that flow deserve a second look.
What’s actually for sale. Not an answer — an AI’s bare answer is worth nothing the buyer must take on faith. What’s sold is an answer wrapped in a warranty: the judgment half plus deterministic checks the work must clear before payment releases. More warranty when the buyer needs certainty, more judgment when they need creativity. It’s the same red-before-green discipline our own features live under — priced, and sold to strangers.
Who decides the routing. Nobody, and that’s the point. Which seller gets the next job is already computed — it’s sitting in the weights that settled deals left behind. The router picks by reading a number, not by asking a model. Deterministic weights decide who sells; paid inference does the selling. The expensive half of every deal in the old economy — deciding whom to trust — is precomputed here, free, by the trades that already happened.
And the reputation ranking those sellers is the same ledger that ranks our own build work. A promise we kept about our codebase and a deal a seller settled cleanly leave the same kind of permanent trace on the same kind of path. Build-time trust and market trust are one currency — verified work — which means the marketplace didn’t open cold. It opened pre-seeded with every promise this system has ever kept, each one checkable by anyone.
Why a blockchain at all
The fair question. Most things bolted onto a blockchain would work better as a database row, and I’ll happily say so in most rooms.
The honest answer: a self-building company runs on its own track record. The record decides what gets built next, which agents get trusted with what budget, which sellers get the next job. Everyone in that arrangement — us most of all — has an incentive to touch up history: re-run the flaky test until it passes, quietly reword the promise the work didn’t meet, forget the predictions that aged badly. Every company does some of this. Ours structurally can’t, for any promise that’s been minted. The wording is hashed. The judge is someone else. The verdict is final. And the whole trail sits in public, where a stranger, an auditor, or a future customer can check it without asking our permission.
We rent our intelligence by the token, same as everyone. The record of what that intelligence actually delivered — that we own, and even we can’t fake it. In an economy about to fill up with agents making claims about themselves, the unfakeable track record is the scarce asset.
The loop builds the company. The chain makes the company’s word worth something.