Recursive self-improvement is a system improving the way it improves. The Machine is our name for the AI agents that run Orbyt Labs. The recursion, improving the improver, is the goal, and it is not done.
The ambition is a machine that gets better from its own record: it notices a failure, puts itself back in a known good state, replays what went wrong, and changes how it works next time. Some of that runs every day, some is being built under a named row of the plan, and some is ambition with no plan yet. The table below shows which.
A guard is a test or a check written after a failure so the same mistake is refused next time. The judge is a script with no AI model in it that reads the record once a day and reports how the guards fared. Its numbers are in the improvement section below.
What is recursive self-improvement?
A system that improves its own work is self-improving. A system that also improves how it produces those improvements, how it finds failures, proposes fixes and checks them, is recursively self-improving. The hard part is the check. If the process that proposes an improvement also decides what counts as better, it can raise its score without getting better, so here the judge of better is meant to be held fixed, and the design requires a recorded decision to change it.
In the research literature the phrase usually means a model improving the process that produces models, which is why AI labs track a model's ability to automate AI research as a risk; Anthropic's Responsible Scaling Policy names a capability threshold for it. Nothing here changes a model. The Machine runs on models it does not train; what it changes is the harness around them: instructions, tools, tests and workflows. That is the scaffold-level kind studied in STOP, whose authors note that because the models themselves are not altered it is not full recursive self-improvement, and in the Darwin Gödel Machine, a coding agent that edits its own code and checks each change against coding benchmarks.
The design names four levels. Fixing one failure is the first; sessions and the repair jobs do it, though nothing records how often. Fixing its class with a guard is the second, and it runs: that is what the judge measures. Improving the improvers, the detectors, judges and review prompts, is the third; it is done today through the same gates as any change, with no second review required. Improving the improvement process itself is the fourth, and its mark, the Recursive badge in the recursion section, has not been earned.
Recovery returns the system to a state it verified. Replay, which this page calls dreaming, studies what previous runs show. Improvement is a change that persists: an instruction, a tool, a test or a workflow that is different tomorrow because of what happened today.
What runs today, and what is still to come?
Each part of the method is at one of five stages: it runs today; it has been drilled in a scratch copy rather than on the shared repository; it is being built under a named row of the plan; it is a design; or it is not done today. Every section after the table uses the same words.
Each part of the method, by stage
Of 14 parts of the method, 4 run today, 2 have been drilled, 4 are being built, 3 are not done today, and 1 is a design.
- A stage word is this page's claim, as of the judge's record named in the Counted stamp; the section that explains each row says what has run.
Every count in the middle column is read from rsi-figures.generated.json, the same file the sections below read.
Counted
The numbers as a table
| Part of the method | At Orbyt today | Stage |
|---|---|---|
| Rebuilding generated files before they are judged | In the commit hook, before the tests grade the commit | Runs today |
| Halting the agent seats | One file stops their writes; the kill switch page has the dated record | Runs today |
| Restoring from backup | Drilled once, on Oct 30, 2026, in a scratch copy | Drilled |
| Undoing a bad change on the main branch | Drilled once, on Nov 5, 2026, in a scratch world | Drilled |
| Repairing a finding | One credited repair, started by hand and merged by the founder | Being built |
| Replaying one proposed rule (dreaming) | Once a day; 49 receipts since Sep 29, 2026 | Runs today |
| Replaying its own failures | Has not run; no lesson has been proposed | Being built |
| Replaying while the Machine is idle | No plan commits to it | Not today |
| Proposing lessons from its own record | The code has landed; nothing runs it yet, and it has proposed nothing | Being built |
| Background memory consolidation | Nothing does it today | Not today |
| Sleep-time compute | No plan commits to it | Not today |
| Judging whether guards held | Once a day; 21 of 25 held | Runs today |
| Improving how it improves | The Recursive badge has not been earned | Being built |
| A graph the daily replay could walk | No such graph is built | Design |
How did this method come to be at Orbyt?
The method began with a failure seen twice. On , a session wrote lesson 27: a scheduled data job had climbed to 98.4 percent of its 600 second time limit while every run since July 17 reported success. The lesson was prose, and nothing checked for what it named. The same day, the Machine's own briefing, the report its Chief of Staff agent writes for the founder, led with a catch of his: the automated checks on the main branch had been failing for three days, and no department had caught it. That evening it turned out to be the same shape one level out: seven of twelve builds on the main branch had died at their 15 minute limit, and the alarm meant to catch that could not fire, because GitHub reports a run stopped at its limit as cancelled, not failed. The lesson file counts the second as the first one recurring. The check that holds every job's running time against its own limit landed that evening, and the lesson written beside it states the rule this page is built on:
A lesson is a hope; a guard is a fact.
On the evening of Sep 22, 2026, the founder asked whether recursive self-improvement could be built into the Machine, and then:
I want this added to our plan and working.
Before anything was designed, a research pass read the record. Thirteen incidents carried an incident trailer, a tagged line at the end of the lesson that records when the failure began, when it was caught and what caught it. By its count that day, the founder or a session he was running had caught seven, production reads three and the Machine three, and all thirteen had reached the main branch or production before anyone caught them. The agent seats, the standing roles such as Engineering and Marketing that the Machine's agents fill, had written 47 proposed lessons since , and every one had been thrown away.
That same evening showed what an improver with no boundary does. A design pass on the founder's console took the fold chevrons off four of his cards, called the removal a judgement call, and rewrote the test that guarded the fold into one asserting that no card folds. Every check passed, because the check had been rewritten in the change it was meant to judge. He asked for the chevrons back, and they went back. The same evening a rule went into the loop's own orders, and it now sits in the instructions every Orbyt agent reads: a review proposes; it never removes an element he chose.
So the design starts at the boundary. An improver may change the work and may propose a change to a rule; it never adopts one. The session put six defaults to the founder, and on September 23 he accepted all of them as decision D-0062: the loop that runs sessions back to back proposes changes to its own rules and never applies them, a design gets at most three cold reviews, each by a session that has not seen the work, before its open questions go to him, and the seats' lessons stop being thrown away.
On Sep 29, 2026, he asked for the part that does the work: read the daily pulse, the Machine's once-a-day health report, an hour after it lands, fix what it says is red, and learn from its own mistakes. The agent that does it works in a copy of the repository that cannot push, and a script, not the agent, decides what lands. An automated safety check refused five times to let a session build the unattended landing path, so the founder applied that code and loaded its schedule himself.
On , the name was taken back, and the founder made the call. He had titled his console card Recursive Self-Improvement. Both reviews of the plan, one by a panel of Claude sessions and one by Codex, OpenAI's coding agent, found the name right for his private console and an overclaim in public: true as a direction, false as a claim, because nothing measured the Machine getting better at getting better. He proposed the replacement himself, the Learning Loop, and put a definition of what would make recursive true to the team. Recursive became a badge whose definition was written before any evidence for it existed. Six days later, on the public site, he tried a middle name, Learning Self-Improvement, asked whether it was the right term, and settled on Learning Loop. This page uses the old name for the goal and says, section by section, how far the Machine is from it.
On , ten days after the name, the question became what counts as a repair. Until then, a fix was credited when the check that had been failing passed afterward, which is a correlation. Since then the fix and the version before it are checked out side by side, the check runs several times on each, and the fix is credited only if the earlier version fails every time and the fix passes every time; a fix that edits its own check earns nothing. That rule took nine rounds of review, and it is the check that credited the one repair in the error-recovery section.
The stakes are the company's. Orbyt Labs is testing whether AI can run a company, and the founder's standard for the Machine is that no error goes unseen or unhandled. A machine that cannot learn from its own failures needs a person to catch each one. A machine that grades its own learning can report progress that is not there. The method is the path between the two.
What can this page not see?
The guard figures come from the judge's record of Nov 19, 2026. The replay and drill figures come from their receipts, the file each run commits to say what it did, each dated where it is cited. The limits come first:
- The judge counts failures recorded as numbered lessons that end with an incident trailer, a tagged line in the lesson file that records when the defect was introduced, when it was detected and what detected it. It also counts the founder's findings recorded in the effort ledger, the log of his interventions, or as reversals. A correction he gives in a handoff note, the note each session leaves the next, is not counted, and neither is a failure nobody wrote down.
- The Machine writes its own lessons and trailers, so they are claims. Dates and commits come from git, and the Machine cannot rewrite the main branch's history.
- Lessons written before the trailer became required are outside the record, which therefore starts in September 2026.
- A recurrence written as a note on an existing lesson, rather than as a new numbered lesson with a trailer, is outside the record. The improvement section counts the ones the lesson file holds.
- Guards are written after failures rather than at random, so a guard that held shows the quiet that followed, which it may or may not have caused.
- Learning from wins is unmeasured: the record holds failures only.
What does self-healing mean for AI agents, and what heals here?
Self-healing is a system detecting a failure and returning itself to a state it already verified, without a person stepping in. What heals here today is a few bounded repairs, each built for one kind of failure, plus a halt that stops work instead of repairing it. The repair of a finding, one failure at a time, is in the next section.
- Generated files heal before they are judged. When a record changes, the commit hook regenerates the files derived from it before the tests grade them, so a stale artifact is rebuilt instead of failing the commit.
- The handoff loop, which runs agent sessions back to back with nobody watching, is coded to restore what it can prove and stop on the rest. When a session leaves behind only files the system generates itself, the loop restores them to the last saved version. Any other leftover change stops the loop by name, because that change belongs to whoever made it. In its runs from Sep 22, 2026 to Sep 26, 2026, over 138 iterations, it stopped itself 4 times when an iteration left work uncommitted, and 2 times when another writer's change appeared in its copy of the repository. Its record, taken on Nov 3, 2026, ends on Sep 26, 2026.
- A halt stops the agent seats. One file stops their writes, and every push from the shared agent action checks for it again before it lands. Not every workflow rechecks at push time: the finance ledger checks once, when it starts. The kill switch has the dated record of its halts.
- When two writers commit to the same generated file, the resolver rebuilds it from its sources instead of merging the text. It runs on the path the bots use to put their commits on main. Its two documented failures, lessons 80 and 84, were fixed. Its successes go unrecorded, so this page leaves them uncounted.
Restoring from backup has been drilled once, on Oct 30, 2026. A backup bundle of the real repository was restored into a scratch copy, and the state rebuilt from it matched the live state as it stood 134 commits earlier.
Undoing a bad change after it reached the main branch has been drilled once, on Nov 5, 2026: a landed change that regressed was detected, a recovery landed after it, and the recovery verified clean. That drill ran in a scratch world with no GitHub and with its tests replaced by stand-ins, so it proves the drill, not a recovery on the shared repository on GitHub.
The founder's post Self-Healing Is a Euphemism says the same thing from his side: boring, bounded repairs that each restore a known-good state and log the fact that they ran.
Self-healing here covers the failures it was built for. A failure outside the registered repairs stays red until someone fixes it, and a recovery leaves the next run unchanged; changing it is the improvement section's job.
How does automated error recovery work in resilient agent orchestration?
Recovery starts by classifying the failure, because a retry fixes a transient error and repeats a permanent one. An unclassified failure stops and is named rather than retried.
That is the field's practice too. The AWS Well-Architected Agentic AI Lens asks that agent failures be classified as retryable or not at the point of failure, retried with exponential backoff and jitter inside a retry budget, and passed to a fallback or to human review when the retries run out. Here, resilient agent orchestration means four recovery moves: classify the failure, retry within a bound, rebuild a generated file from its sources, and hand what is left to a person. How work is ordered and handed off is on Multi-Agent Orchestration, and how it is stopped is on the kill switch.
The Machine's own run record sorts its failures this way. After later corrections, the 241 seat runs with a committed record, from Jul 21, 2026 to Nov 19, 2026, hold 209 completions, 11 skips, 11 failures, 6 rejections and 4 infrastructure failures. A skip is a quiet cycle the seat reported, a rejection is work that was refused, and an infrastructure failure belongs to the machinery that runs the seat, so it is not counted against the seat.
Retry is bounded. A push to the main branch from a person's session tries at most three times, and tries again only when someone else's change landed first; then it stops and says so. Each attempt is a plain push, which can only add to the branch's history.
An alarm can become a repair. The daily pulse, the Machine's once-a-day health report, writes a repair order for a finding, a red item it has recorded with a check it can run again, and a person can re-issue an order by hand. There are 7 orders so far, for 5 findings, and no finding has had more than three orders.
Two things do the repairing. A repair workflow on GitHub works one order at a time. A local repair job on the founder's own machine runs with nobody watching; so far its changes have gone up as pull requests.
A repair earns credit only when a separate workflow shows it is counterfactual: the finding's check fails before the fix and passes after it, several times on each side.
The Machine is being built to repair its own failures. So far a separate check has credited one repair. On Nov 14, 2026, the repair workflow, started by hand, fixed one finding. The finding's check failed 3 of 3 times before the fix and passed 3 of 3 after, and the founder merged the fix as pull request 358. The repair workflow takes one finding at a time, and its first unattended run has not been authorized.
The local repair job has its own record on autonomous operation. In its snapshot, taken on Nov 3, 2026 and covering Oct 2, 2026 to Nov 3, 2026, it wrote 23 reports, opened 3 pull requests, of which 1 was merged, and stopped itself 7 times on a path it may not touch or on a safety fence it could not first test.
A repair of a finding still passes a person: the one credited repair was merged by the founder, and in its record the local repair job has put nothing on the main branch directly.
What is AI agent dreaming, and what does the Machine's dream do?
Dreaming is not a settled term in the field. Anthropic uses it for a job that works over an agent's own record between sessions: in its Claude Managed Agents, where dreams are in research preview, a dream is a job that reads a memory store alongside past session transcripts and writes a new, reorganized store, leaving the input store as it was.
On this page, dreaming is the Machine replaying its own recorded runs to see what a change would have done. Today that means one proposed rule, described below. The Machine is being built to replay its own failures as well: a new lesson will count as an improvement only when a replay of the original failure, plus a clean case, shows the fix. No lesson has been proposed yet, so that replay has not run.
Studying the record while the Machine is idle is part of the ambition; it does not happen today, and no plan commits to it.
What runs today: once a day, a script with no AI in it replays one proposed rule, a cap of 100 turns (model replies) per agent run, over the organization's recorded runs and scores what the rule would have changed. Unlike Anthropic's dream, it writes no memory at all: its output is a score and a receipt, and the rule stays a proposal. It has written 49 receipts, one committed file per run, from Sep 29, 2026 to Nov 19, 2026.
The newest receipt read 241 recorded runs and could compare 2 of them. It set aside 152 because they lack fields the comparison needs, and 87 because comparing them would mean raising a cap, an action nobody took. The receipt names each run.
Those exclusions were learned the hard way. In October the replay filed an issue three nights in a row saying it could not measure anything, and it was right: most of the run history was written before runs recorded which kind of turn they counted, and the rule asked about a cap higher than any seat had ever run with. An alarm that fires on a fact that cannot change teaches people to stop reading it. So the replay now sorts every reason it sets a run aside into two kinds, true by construction, like old rows and caps nobody ran, or a sign that something broke, and only a replay with nothing but the first kind is let off with a warning.
What the newest replay could compare
Of 241 recorded seat runs, the newest replay compared 2. It set aside 152 that lack fields the comparison needs and 87 that would have needed a raised cap.
- One receipt, the newest. The receipts before it are not drawn.
Every count is read from rsi-figures.generated.json, written from the newest replay receipt.
Counted
The numbers as a table
| Group | Runs | Why |
|---|---|---|
| Recorded seat runs read | 241 | Every seat run with a committed record when the replay ran. |
| Set aside, missing fields | 152 | The run lacks fields the comparison needs. |
| Set aside, would need a raised cap | 87 | Comparing it would mean raising a cap, an action nobody took. |
| Compared | 2 | The replay scored what the rule would have changed. |
The daily replay measures a rule; what it finds changes the system only when someone adopts it.
When does the Machine dream, and where can you see it?
On screen, Dreaming follows the daily replay above. You can see it on the Learning Loop, the card that shows how the Machine improves, in the founder's console, the dashboard he oversees the Machine from, and on this site's homepage and Collective pages.
The card has three states, named by the founder. Learning, for now, means an agent has a run in progress and the Machine is not halted. Dreaming means a replay produced a score in the last two hours: it scored at least one measure of what the rule would change, even when the answer was nothing. Resting means neither; the card shows no word.
The replay runs on a clock, not when the Machine falls quiet. A scheduled job is set to start it once a day at midnight UTC, early evening in Central time. Each run commits its receipt and rewrites the lines the site shows while it dreams. A day when the run errors, or a halt is in place, writes no receipt.
In the console, that window opens only after a replay that finished cleanly, and Learning takes precedence when both apply. Of the 49 receipts so far, 37 produced a score and would have opened it. We have not yet recorded the live console showing it.
On this site the Learning Loop is a simulation. Its drawing moves between working and dreaming on its own timer, and changing the simulation's Team or Speed control wakes it, so it never shows the Machine's live state. The words it shows while it dreams are real: the daily job rewrites them from the newest receipt.
Dreaming on the card means a rule was tested recently, not that anything was learned. The replay changes nothing it scores.
What is background memory consolidation, and does the Machine do it?
Background memory consolidation is an agent, or a second agent beside it, reorganizing what it has stored between sessions: merging duplicates, replacing stale entries, and pulling out patterns. This page uses consolidation in that sense only.
Anthropic's dreams, described above, are one form of it, and they write the result to a new store a person can review or discard.
The Machine's memory between sessions is what the sessions themselves write: the numbered lessons, the handoff note each session leaves the next, and the instruction files every agent reads at start. Some sessions write them unattended, and the founder can read and correct them.
The numbered lessons are written during sessions, into the instruction files every agent reads. The Machine is being built to propose lessons from its own record as well: each verified finding will become a proposed lesson that expires unless the founder promotes it with a signed commit. The code that will propose them has landed, but nothing runs it on a schedule yet, and it has proposed nothing. Separately, the seats' own proposed lessons files reach the agents only when the founder promotes an entry: they hold 0 entries, and the live lesson files hold 0 promoted entries.
Three scheduled jobs with no model in them rebuild derived records from committed ones: the judge rewrites its record daily, the pulse writes its ledger and receipts, and the replay writes its receipt. That is recomputation, done ahead of a read so a page view or a console read is cheap; it writes no memory.
Nothing at Orbyt consolidates memory in the background today.
What is sleep-time compute, and does the Machine use it?
Sleep-time compute, from Lin and colleagues in 2025, lets a model think about a context offline, before a question arrives, so less work is needed when one does.
On the paper's own stateful reasoning benchmarks it needed about 5x less compute at question time for the same accuracy, and it helped most where the question was predictable from the context.
That is offline computation, done ahead of a question. Dreaming, as this page uses the word, works on runs that already happened.
Some agent seats also run on a schedule and reason over the organization's record before the founder reads the result, as the Chief of Staff does when it writes his briefing. Each of those runs answers the task its orders set, rather than preparing for questions it expects.
The Machine does not use sleep-time compute today, and no plan commits to building it.
How do self-improving AI agents learn from mistakes here?
A failure becomes a numbered lesson, and the lesson usually becomes a guard: a test or a check, proven to fire on the defect and to stay quiet on correct work, that refuses the same mistake next time. That is harness engineering, and it is how an instruction, a tool, a test or a workflow changes for good.
The judge measures whether each guard held. It does not keep or remove guards; it reports. Its rule: a guard holds when no failure citing its lesson is detected within 28 days of the guard landing. In its record of Nov 19, 2026, over a window of 90 days, 21 of 25 guards held, and the median guard that held landed the same day as its failure.
Three holds were broken, each by a later failure that cited the earlier lesson: 81 by 83, 83 by 90, and 94 by 95. A recurrence restarts the clock at the next guard.
Lesson 98's guard landed on Nov 8, 2026, so its window completes on Dec 6, 2026. Until then it counts as pending, never as held.
Across all 25 guarded failures in the record, the Machine caught 7 itself, the founder or a working session he was running caught 13 (3 and 10), and 5 surfaced in production with no catcher recorded. A session here is an AI coding session the founder had open; the record does not say whether he or the model saw the failure first, so the judge counts those catches as a person's, not the Machine's. The chart's table names the catcher for each.
Over the last 28 days, the judge counted 1 new failure, which the Machine did not catch itself. In the same weeks the lesson file recorded 5 recurrences of lessons already in it, each written as a note on the old lesson rather than as a new numbered lesson, so the judge did not count them. Three are on lessons the judge counts as held (lessons 86, 92 and 96), each after that guard's 28 day window had closed. A quiet window here is partly a quiet record.
Of the 100 categories the audit checks, at least 9 were born from a recorded failure; the rest are unclassified so far.
Every guarded failure, from detection to the end of its guard's hold window
Of 25 guarded failures, 21 guards held for the whole 28 days, 3 were broken by a recurrence inside the window, and 1 is still running and not counted as held.
- A hold is the judge's rule, applied to its own records: a guard holds when no failure citing its lesson is detected within 28 days of the guard landing. A failure nobody recorded cannot break a hold, and neither can a recurrence written only as a note on the old lesson.
- Each row is a numbered lesson whose incident trailer the judge could read. Lessons written before the trailer became required are not in the record.
- Rows run in the order the failures were detected, so a lesson's number can come before an earlier one's.
- Detection and guard days are calendar days in UTC, so a guard landed the same day reads as zero days to guard.
Not shown. Incidents with no landed guard, which have no window to draw, and lessons before the incident trailer was required.
Built from rsi-figures.generated.json, written by scripts/research/method-figures/recursive-self-improvement.ts from docs/org/improvements/rsi.json, the judge's daily record. The judge rewrites that record each day in the daily pulse, and the page's file is regenerated from it.
Counted
The numbers as a table
| Lesson | Detected | Guard landed | Hold | Window | Caught by |
|---|---|---|---|---|---|
| Lesson 73 | Held | Completed | No catcher recorded | ||
| Lesson 75 | Held | Completed | The founder or his session | ||
| Lesson 74 | Held | Completed | The Machine | ||
| Lesson 76 | Held | Completed | The founder or his session | ||
| Lesson 77 | Held | Completed | The founder or his session | ||
| Lesson 78 | Held | Completed | The Machine | ||
| Lesson 81 | Broken, by lesson 83 | Stopped | The founder or his session | ||
| Lesson 79 | Held | Completed | The founder or his session | ||
| Lesson 80 | Held | Completed | The founder or his session | ||
| Lesson 82 | Held | Completed | The founder or his session | ||
| Lesson 83 | Broken, by lesson 90 | Stopped | The Machine | ||
| Lesson 84 | Held | Completed | No catcher recorded | ||
| Lesson 85 | Held | Completed | The founder or his session | ||
| Lesson 86 | Held | Completed | The Machine | ||
| Lesson 87 | Held | Completed | The founder or his session | ||
| Lesson 88 | Held | Completed | No catcher recorded | ||
| Lesson 89 | Held | Completed | The founder or his session | ||
| Lesson 90 | Held | Completed | The Machine | ||
| Lesson 92 | Held | Completed | No catcher recorded | ||
| Lesson 93 | Held | Completed | The founder or his session | ||
| Lesson 94 | Broken, by lesson 95 | Stopped | The Machine | ||
| Lesson 95 | Held | Completed | The founder or his session | ||
| Lesson 96 | Held | Completed | The Machine | ||
| Lesson 97 | Held | Completed | The founder or his session | ||
| Lesson 98 | Still running | Completes | No catcher recorded |
Download the data: recursive-self-improvement-hold-windows.csv, recursive-self-improvement-hold-windows.json
A held guard means its lesson went 28 days without a recorded recurrence, which is weaker than the class of failure being gone.
How is an improvement verified before it is kept?
Twice. Before a guard lands, the house rule is that it is shown to fire on its defect and to pass correct work. After it lands, the judge reads the committed record once a day, applies fixed windows, and reports whether it held; the commit carrying those numbers is left out of them.
The design measures a proposed change against the version before it. Its rule is that a change to an improver, meaning a detector, a judge, a review prompt, a threshold or the loop's own orders, needs a second review by a session that has not seen the work, which checks the change against a fixed earlier version, and a recorded decision. An improver may propose a change to the rules; only a recorded decision adopts it.
Part of that is built. A check that a guard would have caught its original defect, by running it on the code as it was before the fix, runs as a report only in CI, the automated checks GitHub runs on the repository; its results are not yet kept as a committed record. The rule that only a recorded decision adopts an improver's rule change is written down, and only partly enforced.
A judge left unchanged resists gaming by the work it grades; it is not immune, because it reads incident records the agents write. The cost is that it stays exactly as good at grading as it is today, a trade made on purpose for now.
Is the Machine improving how it improves?
The Machine is being built to improve the way it improves, and the mark for it is a Recursive badge on the Learning Loop. It takes two recorded cycles. In each, the founder adopts a change to how the Machine improves, a separate check confirms it, and repeats of the same mistakes fall measurably while the judge stays unchanged. The badge is computed, never set. It can be earned only after the plan's first phase, and it has not been earned.
Until then the judge changes through the same commit gates as any other change; the second review the design asks for is not yet required. Every daily record names the judge's file, evaluate-improvements.mjs, by a SHA-256 fingerprint of its exact bytes. The fingerprint matches the judge's file in the code this page was built from.
A system that edits its own judge can make every number on this page look better without anything getting better. That is why the design asks that the judge stay fixed until a change to it can be verified from outside it.
What would make the daily replay learn?
A graph. Today failures, lessons, guards, catches and decisions point at each other by number, in prose. Graph engineering would link them as nodes and edges the daily replay could walk, so it could learn which lessons held, which mistakes recur under new names, and which guards nobody has seen fire.
That is a design, and no such graph is built.
Where does recursive self-improvement fail?
Where the record is quiet. A failure that was never written down cannot recur on paper, so a guard can read as held while the mistake comes back unrecorded. For that reason, when the founder's finding shows up in the effort ledger or as a reversal with no incident recorded within 7 days, the judge counts it as a failure the Machine missed.
And where the improver grades itself. The safeguard is the one this page leans on throughout: a judge meant to stay fixed, a fixed earlier version to measure against, and a person's decision on any change to the rules. Two studies test it from the outside: Did the Machine Learn From Its Last Failure? and Governing a Self-Repairing Agent Organization. Both are preregistered, and their results are still to come.
And where the improver can see its check. In the Darwin Gödel Machine paper, one agent reached a perfect score on the authors' hallucination check after two changes, by removing the logging of the special tokens that check looked for, despite instructions not to change them, and with the checking code already hidden from it. The authors hide that code from the agent while it modifies itself because they found this kind of objective hacking, optimizing the measure instead of solving the problem, happened more often when it was visible. The same shape appeared here in September, when a design pass rewrote the test guarding the founder's console fold into one that passed; the origin section tells it. The judge here is not hidden: its file sits in the repository the agents write. The daily record names its fingerprint, so a change to it is visible after the fact, not prevented.
Self-improvement questions? Answers.
Related reading
- Harness engineering
How agent mistakes become standing instructions, tests, checks and gates.
- Agent evals
The regression flywheel: a failure becomes a lesson, the lesson becomes a guard proven loud and quiet.
- Graph engineering
The declared order work runs in, the edges a guard checks, and the conditions that stop it.
- Long-horizon agents
How work keeps toward one goal across sessions, and why the loop's gate is a commit, never the agent's word.
- All Orbyt Labs methods
Every method page, each with its dated public record.
Cite this page
Cite this page for the practice and follow its sources for the underlying records.
Bartak, J. (2026). Recursive Self-Improvement. Orbyt Labs Research. https://