Self-improvement is an actuation problem.a fleet that mines its operator's corrections into versioned policy, and the three cycles it took for that loop to close without me.

The best training data a fleet produces is thrown away with the sessions.

Where does improvement signal for production agents come from, if not benchmarks? From the corrections the human keeps having to make. When an operator has to tell an agent, dozens of times across a corpus, to keep driving until the work is actually done, or to verify a claim against the running system before reporting it, that repetition is a precise, repeated label on a dropped habit, generated for free by real work. Nearly every agent program lets it die in the transcript archive.

The corrections reduce to a small set of intents, and the intents are the taxonomy this whole system runs on. Do not stall; keep driving until the outcome is real. Own the whole task, not the fragment that was convenient. Verify against the running system before reporting. Own the surrounding system, not just the diff. Ground answers in the recorded decisions instead of guessing. Leave a clean state for whoever comes next. Each names a failure that compounds: the half-done task an agent abandons becomes the false baseline the next session inherits. One specimen shows the shape. An agent reports a fix as done; the operator replies that the dashboard still renders nothing, and tells it to verify before reporting. The miner labels that window verify-then-report. A week that produces several more windows like it turns the label into a candidate habit, and the gate then decides whether the habit generalizes. The cost of leaving those habits uncorrected is measurable. Over 75 days, holding the fleet's backlog flat had required closing 536 issues and abandoning 45 pull requests, most of that pruning done by hand. That churn is what the corrections were being spent on, and it is what a learning loop is for.

A weekly loop that mines the operator, and folds what survives into policy.

The mining pass is deliberately cheap. The transcript corpus stood at 4,190 sessions, 1.8 GB, when first counted. A week's delta is about 356 sessions; a deterministic prefilter, no model involved, keeps the sessions where a human actually intervened, 124 of them that first week. A small model then labels each correction window, 208 labels that week, and one frontier-model call synthesizes them into candidate habits with the evidence attached. A full week of learning costs roughly 125 small-model calls and one frontier call. Thirty-three of the 208 labels were junked as mood rather than signal: the miner keeps what a correction was about and discards how it was said.

Candidates do not touch the fleet directly. They land as a written weekly proposal, and acceptance is a separate, deterministic step: habits that pass fold into a versioned behavioural layer that every agent loads before substantive work, while the agents' core instructions stay frozen. Every verdict, accept, reject, or escalate, becomes an append-only row on a ledger. The fold is the moment learning becomes behaviour, and everything else in this note hangs on one question: does that moment need me?

Producers alive, actuation zero. The gap a demo never shows.

A self-improvement loop has five stages: observe real work, propose a change, accept or reject it, distribute it to the agents, and verify it changed behaviour. Most of what is sold as self-improvement demonstrates the first two. Proposals are easy, and they demo beautifully. The claim worth diligence money lives in the last three. So I turned the fleet's own discipline on itself and audited it against one standard: show me a behaviour change that landed with no human in the chain.

The producer half looked exactly like the brochures. Across the fleet's roughly fifteen repositories, a review daemon had produced 4,292 code reviews in the previous two weeks; the weekly mining job had fired unattended three cycles running; 118 documentation merges had landed by machine. Every producer green, every schedule kept. Then the actuation side. The versioned behavioural layer had changed exactly once in its life, and that one change shipped inside the pull request that delivered the fold machinery itself. The single unattended attempt to fold new learning had quietly done nothing: the producer wrote its findings in one format, the consumer expected another, and every candidate escalated into a review queue nobody was reading. Escalations sat unread for twelve days. Origination told the same story from the other side: 204 of 204 issues opened across the fleet in 21 days came from me, and the merged changes traced to my sessions at ninety-seven percent or above.

The audit's most instructive finding was about my own behaviour. When that fold had failed, I had fixed the proposal file by hand and moved on. The artifact looked repaired; the loop stayed broken; the next scheduled run was guaranteed to fail the same way. Patching the artifact instead of the loop is how a system stays dependent on you while appearing to heal.

The stake generalizes past my desk. If an improvement loop secretly ends in a human's reading queue, its throughput is that human's attention, its latency is their calendar, and the day they stop reading, the learning system stops learning and nobody notices.

The tempting design keeps a person approving each change. It fails three ways, and I lived all three.

The obvious safe design puts a human in the acceptance path: the loop proposes, the person reviews, nothing lands unapproved. It fails on volume, on visibility, and on endurance.

Volume is the polite failure: thousands of sessions a week distill into a steady stream of candidates, and reviewing them is a job nobody was hired for. Visibility is the structural one: a single soft behavioural rule produces an effect far too small to see in any one session, so the reviewer is asked to judge something that is only visible as an aggregate across many sessions, which is a machine's kind of seeing, not a person's. With nothing real to judge at that grain, approvals become rubber stamps or the queue becomes a graveyard. Mine became a graveyard: twelve days of unread escalations, and one cycle that opened ten proposals across the fleet with no consumer for them but a person.

Endurance is the failure nobody writes down. The reviewer stops. Not dramatically; they just have a week where the queue loses, and the system, whose only acceptance path was that queue, silently stops learning. Any design whose steady state depends on a human doing a machine's chore will decay to exactly that.

Acceptance the loop cannot fake. Rejection as the healthy default.

What replaced the per-change human is a deterministic fold: one writer, a versioned behaviour file, a recorded base version, and an append-only ledger row for every verdict. The verdicts themselves anchor outside the agent's own opinion. A candidate habit must survive held-out replay: does it actually generalize to sessions it was not mined from? And the habits that do land are the ones whose absence shows up in outcomes that are true whether or not any agent believes them, merges that survive without revert, gates that pass, work that does not boomerang.

The gate earns its keep by what it kills. One mined habit fit twelve occurrences in-sample and looked obviously right; on held-out sessions it went zero for zero, no generalization at all, and was rejected, reversibly, with the reasons recorded. The first run proposed six candidate habits; three hold in production today, each having survived held-out replay. Surviving replay proves a habit generalizes, not that it pays; that harder question waits at the end of this note. Nor does per-habit replay certify the sum: whether habits stay safe as they accumulate is an interaction question, and a separate gate this fleet has not built yet. A loop that accepts most of its candidates is accumulating, not learning.

Two more pieces keep the gate honest. First, the proposing agent never supplies the acceptance verdict: a loop scoring its own improvements is a contaminated anchor, and the collapse literature documents what happens to systems trained or selected on their own outputs. Second, what the gate cannot decide, it escalates with finality. When the miner surfaces a genuinely new category of behaviour, the question goes to a panel of four models from different model families, whose separate votes and verdict land on the ledger the same day. The human's job moved up a level: I write the standing policy, the objective, the taxonomy, the override rules that always beat a learned habit, the review cadence, versioned like any other production configuration, and then that policy runs without me in the per-change path.

It ran green. It was blind.

The first time the repaired chain fired with nobody watching, it ran end to end: mine, propose, fold, escalate, verify. Exit code zero. The watcher checked it thirty-five minutes later and reported healthy. That morning is when the system taught me the difference between green and true.

Under scrutiny, the green run was carrying three silent failures. It had judged the week against a stale base: the live behaviour file had moved a version ahead, the runner never pulled it, so the cycle re-derived and re-escalated questions that were already settled. About seventy network resets in the labeling stage had been swallowed into the phrase "no signal this week", which made a broken endpoint indistinguishable from a genuinely quiet week. And the exit code was zero over all of it, so the watcher, which checked exit codes, blessed the whole thing. The same morning, a parallel rules stream opened ten proposals across the fleet, and all ten were noise: the two highest-frequency "rules" had faithfully mined bot apologies, 29 comments' worth, and tool warning banners, 47 comments' worth. The loop had closed mechanically and delivered nothing.

The repairs are more interesting than the failure, and each one is general. The watcher now asserts internal invariants rather than exit codes: base freshness against the live file, network-failure rate in the labeling stage, the age of the last fold, and an explicit degraded-mode marker whenever an outage would otherwise impersonate silence. A machine adjudicator followed, and now sits where I used to: it adopts on coded criteria, defers weak signal into an incubator where recurrence can strengthen it instead of deleting it, escalates ambiguity to the panel, never auto-closes anything tagged as a security concern, and force-escalates a random five percent of its own closures for audit, so it cannot become a silent tyrant. A cycle that opens ten proposals and closes all ten now reports zero, loudly, instead of celebrating throughput.

The regenerated cycle then closed clean: a healthy run recorded on the ledger, one real escalation filed, adjudicated four to nothing by the panel the same day, verdict and reasons on the ledger, and no per-change human judgment anywhere in it. It was the loop's third unattended attempt. The first had quietly done nothing, defeated by a format mismatch; the second exited zero while carrying three silent failures. The third closed, with the evidence on the ledger.

Two more cycles, and the honest ledger of them.

The next cycle ran healthy and unattended, with two new taxonomy escalations recorded for review. The cycle after that, the ledger reads "quiet week: zero signal with zero stage-one errors." Before the repairs I would not have believed that line, because a dead endpoint produced the same sentence. Now it is the most trustworthy row on the ledger, precisely because an outage would have written a different one. Being able to say "nothing to learn this week" and be believed turns out to be one of the harder engineering artifacts in the whole system.

The same cycle supplied the counterexample. A scheduled audit found a parallel producer dead at load: a one-line metadata mistake that the CI runner rejects outright, so every run of that leg had been failing before its first step. Its watcher did not exist yet. The fix came with a regression guard so the mistake class dies in continuous integration rather than in a scheduled job nobody reads. The lesson is not that the fleet is fragile; it is that every leg of a learning loop needs its watcher, and the legs you have not instrumented are exactly the ones that are currently lying to you.

Two disciplines from those cycles are worth stealing outright. First, measure a stage before wiring it in. A distillation stage, meant to turn raw mined clusters into imperative rules, was run against forty real clusters before being granted a place in the weekly path: it killed four as noise and upgraded thirty-six into specific, actionable rules, against a brutal baseline, since lifetime adoptions of the raw undistilled rules stood at zero of twenty-three. Running it live also surfaced that it had never once executed in production and carried two defects only a real call reveals. The stage earned its wiring with numbers, not with plausibility. Second, verification can pollute the loop it verifies: proving the escalation path worked once minted three phantom escalations from a test fixture into the live tracker. Local runs are now side-effect-free by default, and anything that mutates shared state requires an explicit live flag.

What transfers, and what this cannot claim yet.

Established by these three cycles. The audit method finds the actuation gap that the word autonomous hides, and the gap was real in a fleet whose producers were all genuinely scheduled and green. A deterministic fold with held-out replay and a recorded ledger accepted three habits, rejected the rest with reasons, and then ran three consecutive unattended weekly cycles, including one honest quiet week and one same-day panel adjudication, with no human judgment in the per-change path. And the end state is worth naming plainly, because it is the value: my attention is no longer the loop's throughput. What reaches me now is one or two adjudicated escalations per cycle and a quarterly review of the rules; raw noise stops at the adjudicator, weak signal is incubated instead of lost, every accepted habit has passed held-out replay, every rejection carries recorded reasons an auditor can walk, and the learning itself costs about 125 small-model calls and one frontier call a week. A fleet that changes its own behaviour under audit, at that price, with that trail, is what a learn-from-usage claim has to show before the word self-improving is earned. Mine could not show it until the third cycle.

Not established, and this note does not claim it. No productivity effect of the folded habits is claimed; the counterfactual efficacy measurement is designed and queued, and until it reports, the habits are validated as generalizing, not as valuable. It is the loop's next gate, not an afterthought. One fleet, one operator, whose corrections are one person's engineering taste. Three cycles prove the pattern, not the scale. The magnitudes are corpus-specific throughout; the structure is the transferable part.