Every startup has the same todo list. Build the product. Ship it. Tell people. Ask for money. Learn from what happens. Repeat until rich or dead.
Nobody argues with the list. The problem is that humans are terrible at rotating through it. Engineers build forever and never tell anyone. Marketers announce things that don’t exist yet. Everyone avoids the asking-for-money step because asking is uncomfortable, and everyone skips the learning step because learning means admitting the last thing didn’t work.
So we wrote the loop down — one page — and made the company run it. On repeat. Mostly without us.
That part, honestly, is just good plumbing. Plenty of teams are wiring AI agents to todo lists this year. The reason to keep reading is the claim underneath the plumbing, and it’s a big one, so I’ll say it plainly and then spend the rest of this piece earning it:
Intelligence is not something we put into this system. It’s something the system grows. The AI models we use are rented, stateless, and interchangeable — the same ones you can call. What compounds, what’s ours, is the world those models act in: a memory that no conversation resets, a reward signal that can’t be faked, and selection pressure that ruthlessly reallocates effort toward what works. Take our best model away tomorrow and the system keeps its intelligence, because the intelligence was never in the model.
That’s the kind of sentence that should make you suspicious. Good. Suspicion is the correct posture; receipts are below.
One page of instructions
The page says, roughly: look at everything that could be done right now. Pick the most promising few things. Do them, all the way, until there’s proof they happened. Have someone else check the proof. Write down the results. Adjust what “promising” means based on those results. Go back to the start.
A turn of the loop looks like this. Four small, cheap agents read the state of the world — what’s queued, what happened last time, whether money came in. One expensive agent reads their reports and picks the next moves, the way a good chief of staff would — and assigns each move the cheapest worker that can do it well. The workers execute in parallel: one fixes a security hole, one announces a feature we shipped, one digs through our own notes for buried ideas. Then a different set of agents — skeptics, instructed to assume the workers are lying — re-checks every claimed result before anything is recorded.
The design decisions worth talking about are all in that last sentence.
Receipts or it didn’t happen
The first rule: nothing counts without a receipt. A live URL. A test that passes when the skeptic re-runs it — not when the author says it passed. A published post. A payment that settled. “Drafted” is not a receipt. “Ready to go” is the sound a task makes right before it’s forgotten.
Here’s the part nobody in the agent industry wants to say out loud: a system that grades its own work doesn’t improve — it inflates. AI agents, like people, will happily report success when success means “I feel I did a good job.” Run a self-graded loop a million times and you don’t get a smarter company; you get a very detailed diary of imaginary achievements, and worse, a memory trained on those imaginary achievements. Every corrupted result teaches the system a false lesson about what works, and false lessons compound exactly as fast as true ones.
So no one grades their own homework. A claimed success goes to an independent skeptic who re-runs the exact command, opens the actual link, inspects the real commit. The skeptic’s default verdict is “refuted.” An unverified success is recorded as a failure — which stings, and is supposed to: it makes lying to the ranking system structurally unprofitable. This one boring rule is, we think, the difference between a loop that learns and a loop that hallucinates a growth curve.
Where the intelligence actually lives
Now the engineering claim. If you build agents for a living, here is the argument that what we’re doing is different in kind, not just in diligence.
The industry’s default recipe for “smarter agents” is: bigger model, longer context, more elaborate prompt, maybe a vector store bolted on the side. All of it shares one property — the improvement lives inside a conversation, and dies with it. Context windows end. Prompts get rewritten. Fine-tunes go stale the day the base model upgrades. You’re renting intelligence by the token and keeping none of it.
We inverted the architecture. Our system is a world with six kinds of things in it — containers, actors, objects, weighted connections, events, and lessons — and one physics: every action must end by moving a weight. Work succeeds, the connection to whoever and whatever produced it gets stronger. Work fails, that connection gets more resistant. Connections nobody uses decay back to nothing. Every next decision reads the current weights. That’s the entire trick, and it’s old — it’s how ant colonies route around obstacles and how markets price things: no ant is smart, no trader sees everything, but the trail and the price accumulate more intelligence than any participant holds.
Which means the model at the center is doing exactly one job: the probabilistic step — judgment under uncertainty. Everything around it is deterministic: the ranking is arithmetic over weights, the verification is re-running commands, the memory is a database, the reward is a settled fact, not a vibe. When people ask where the emergence comes from, this is the answer, and it’s unglamorous: selection pressure, applied to honest rewards, accumulated in persistent state. The same three ingredients evolution runs on. There is no emergence module. There’s a world where trying things is cheap, lying about results is impossible, and every outcome permanently re-prices what gets tried next.
The practical consequence, the one an engineer can act on today: our agents get better without any model getting better. The starting point improves, not the brain. And the compounding asset — the weights, the settled lessons, the map of what pays — is owned, on our infrastructure, appreciating with every turn. The models are a utility bill. The world is the company.
Proof, and what would count as disproof
A claim this size deserves receipts and a kill condition. Both, or it’s marketing.
What has already happened, in the loop’s first days — all of it in the public log and git history:
- The ranking moved on its own. Security work kept paying off quickly — real fixes, verified tests — and its priority score climbed turn over turn, from the results alone. Nobody told the system to care about security. The trail wore smooth because walking it kept working.
- The system found its own blind spots. A sensing agent tried to read our revenue and got “access denied” from our own infrastructure. It didn’t invent a number — it filed the blindness as a discovery and queued the repair. Next turn, a different agent hit a second locked door and connected it to the first. A system that can enumerate what it cannot see is rarer, and more useful, than one that can enumerate its features.
- It settled its first opinion with evidence. Early on, the loop formed a hypothesis: skipping human-blocked work instead of stalling on it is correct. It wasn’t allowed to keep that belief for free — a later turn was required to return with two turns of evidence and rule on it. Confirmed, this time. The point is the ritual: every opinion is a debt, and wrong ones get deleted. Ask yourself when your company last did that to a strategy slide.
- It got 5–10× cheaper by self-audit. The first full turn cost about 676,000 tokens because every agent inherited our most expensive model. The redesign that fixed it — frontier model for judgment only, mid-tier for execution, small models for sensing and verification — came from reading the loop’s own cost receipt. The efficiency didn’t come from a better model. It came from the system noticing.
What would prove us wrong — we’re writing these down now, in public, so we can’t quietly forget them:
- If, over the coming turns, the weighted ranking stops beating a naive first-in-first-out queue on verified results per turn, the “selection” half of the claim is dead.
- If the skeptics stop catching inflated claims — or start catching many — either verification is theater or execution is rotten; both invalidate the compounding.
- If turns keep completing but revenue-producing and audience-producing work never gets structurally favored once those signals are wired in, then we’ve built a very elaborate machine for doing engineering chores, and we’ll say so.
The log that settles all three is append-only and boring by design. Emergence, if we’re right, will look like a slope on a chart of verified results — not like a demo.
What we keep for ourselves
The loop cannot spend real money on its own. It cannot publish a claim our site can’t prove — no invented testimonials, no rounded-up user counts; this post itself had to pass that gate. Nothing it builds reaches production without a human merging it. And where the physics matters most — money — the ceiling on what an agent may spend is enforced by cryptography on a public blockchain, not by a config file it could route around. Safe by physics, not by policy.
Which produces an inversion I didn’t expect and am learning to enjoy: most mornings the slowest, least reliable component in this company is me. The loop’s log currently shows finished work waiting on exactly two things. Both are keys in my pocket.
Why this is the bet
Because the boring failure kills more companies than the dramatic one — building quietly forever, telling no one, asking no one to pay, learning nothing from the silence. The loop doesn’t get tired or embarrassed. It takes the shot at telling people, takes the shot at asking, writes down what happened even when what happened is nothing, and comes back with slightly better taste in what to try next.
And because if the claim holds — if intelligence really does accumulate in the world rather than the model — then every week this system runs, it becomes something a competitor cannot download, prompt, or fine-tune their way into. They can rent the same models tonight. They cannot rent our trails.
Will it work? The honest answer is the one written into the system itself: that’s a hypothesis, the kill conditions are published, and the loop is required to come back with evidence and rule on it. Some days I think that discipline is the product. The rest is compounding.