RSI is recursive self-improvement: AI systems that help create, test and improve the next AI. In September 2026 all the pieces showed up at once. Here is what is real, how big tech, companies and governments will use it, and how you can benefit from it right now.
RSI (recursive self-improvement) is when an AI helps build a better version of itself, and that version gets even better at building the next one. The idea dates back to 1965 (I. J. Good's "intelligence explosion"). What is new in 2026 is that the pieces have left the drawing board: AI already writes the code, builds the training environments, runs the experiments and suggests the next step. Humans still set the direction and decide what gets promoted to the next version.
AI speeds up parts of research (code, experiments, data, GPU kernels) with humans in charge. Examples: AlphaEvolve cut 1% off Gemini's training time; at Anthropic, Claude writes more than 80% of the code.
Multi-step research: the AI proposes ideas, swaps components, runs training and tests, and decides whether to continue or abort. Researchers choose what to test and interpret the results. This is what the startup Simate calls "Physical RSI" in robots.
The system runs the whole cycle, from idea to training its successor, with no human bottleneck. OpenAI and Anthropic say this is not happening today and is not inevitable. What is missing is the ability to choose which problems are worth solving.
Course and explainer on the warning that AI could speed up its own research by 2028: the loop, the METR curve, MirrorCode, where measurement breaks down and the scenarios, separating what is solid from what is speculation.
We started from 3 news videos (in German) and checked every number against papers, system cards and press coverage. confirmed means there is a primary source; partial means the core is right but a detail is wrong or unsourced. The corrections are in the box below.
An arXiv paper (Sept 19) describing sandboxes for training agents: ~3 million per day, a peak of 380,000 running concurrently, more than 5,000 created per second, on 160 servers. In section 6.1, agents build the environments where the next agents train, and pack_diff saves each environment as a reusable "snapshot".arXiv 2609.22978 ↗
Since May 2026, Claude has written more than 80% of the code accepted at Anthropic (up from "low single digits" in Feb 2025). Since August it has carried out ~26% of research work, under supervision. It picks a better next step than the researcher in 64% of the cases tested (up from 51% in Nov 2025).Anthropic Institute, Sept 17 ↗
In the 230-page system card, CoBench 2.1 (diagnosing real incidents) scores 55.8%. The threshold for replacing the research team is 85%. Anthropic says there is no sustained 2× speedup, but METR estimates a ~1.5× speedup, with a ~30% chance of 2×.Anthropic, Sept 22 ↗
"Fully autonomous RSI is not happening today, and we should not pursue it unless and until it can be done safely." It proposes measuring how much of R&D is done by AI, defining when automated research requires immediate human review, and standardizing incident severity, with the US in the lead through CAISI.CNBC ↗
On Sept 6, OpenAI declared it had hit its Oct 2025 goal: around June, agent execution time began to exceed human work, and by August it stood at 3.1 agent-days per human-day. According to The Information, internal models already write and optimize GPU kernels within human-directed research.Help Net Security ↗
Kimi K3 (Moonshot, 2.8 trillion parameters) was trained on the AgentENV platform. Alibaba launched AgentCore and Agent Sandbox (the documentation cites up to 15,000 sandboxes/min). Simate applies weak RSI to robots and took 1st place on RoboDojo. Models are trained with GPUs; agents are trained with environments.AgentENV ↗
Traditional automation runs the same process every time. Cultivated AI runs, observes, learns, proposes a change, tests it and improves its own process. It is the same cycle the labs are building at industrial scale, just applied to your business.
Whoever has the best combination (not just the best model) evolves fastest.
The engine. It tends to become a commodity: several are at a similar level and prices drop with every release.
Models equipped with tools, roles and goals, actually running the process.
The sandbox where the agent can make mistakes without breaking anything. It's what DeepSeek scaled to 3 million a day.
The judge: answer key, primary metric and guardrail metrics. It's the new bottleneck.
The signal that comes back: human corrections, complaints, repeat contacts, sample-based audits.
The history of experiments: what failed, what improved things by 4%, what cost 3× more.
Observability, permissions, budget and the promotion gates into production.
With the same model, an agent with 10,000 evaluated cycles is not the same as a brand-new one. The moat is accumulated experience.
Human work moves up a level: from doing the task, to designing the system that does the task, and then to designing the system that improves that system.
The human asks and the AI answers. The 2023–2024 era.
The human sets the goal and the AI executes. The 2025–2026 era.
Several agents run parts of the process with clear roles. This is where most companies are entering now.
The agents execute, evaluate and improve the system itself. This is where the labs are, and it is the doorway to RSI.
The ready-to-use loop for Claude Code: 9 agents with separate roles, a record of every cycle, a cost ceiling and an undo button. No worse version gets in by the system's own decision.
5 tracks and 21 lessons for owners and managers with no technical background to set up their first improvement loop.
Before the loop, the sheet: intent, metric, limits and autonomy level (N0–N4) for each agent, in 7 questions.
Outside the labs, "RSI" is almost never a model rewriting its own weights. It is an operational learning loop: the agent executes, logs, gets evaluated, gets optimized, gets tested again and is released, with a human controlling the promotion gate.
A prepared company doesn't ask "where should we put AI?". It maps Process → Agent → Execution → Metric → Evaluation → Feedback → Improvement, and every important process starts generating learning: sales learns, customer service learns, finance learns.
Ticket triage, reconciliation, lead qualification. The loop moves fast where you can check whether things improved, and slowly where you can't.
Examples with the right answer. This is your learning asset, and part of it stays hidden from the optimizer to catch cheating and overfitting.
E.g. verified resolution, repeat contact within 72 h, and satisfaction on difficult cases. Without guardrail metrics, you repeat Klarna's mistake.
Log what the agent did, not just what it delivered (LangSmith, Langfuse, Arize Phoenix). Without a record of the process, there is no way to audit.
Sandbox, least-privilege credentials and a capped budget. DSec's agents forged messages and crashed machines; yours may try shortcuts too.
An experiment journal: what was tried, the result, the cost and the decision. It's the context that lets the next cycle start smarter.
Two practical tracks, one for business people and one for technology people, based on what worked (and what broke) in 2025–2026. Pick yours:
Something repetitive, with volume and an outcome you can check. Write in one sentence what "done well" means and what the agent must never do.
One primary metric and two guardrail metrics. A good average with poor results on difficult cases is the classic mistake: don't optimize for time or volume alone.
Gather 20 to 100 real cases with the right answer. It is the most valuable work on this track, and only people who know the business can do it.
Run the agent in parallel or with human approval. Every week, review the failures and feed them into the answer key and the knowledge base. That is LOOP-R turning.
Only increase autonomy (what the agent decides on its own, and with what budget) once the metric has been stable for weeks and the sample audits come back clean. Log everything for LGPD (Brazil's data protection law) compliance.
Your job becomes goals, limits, metrics, budget and deciding what gets promoted. Bring the loop's numbers to management, not "how many tasks the AI did".
Log every call, tool, cost and relevant reasoning. Without traces there is no critique and no improvement.
# open-source option for traces + evaluation pip install arize-phoenix # or use LangSmith / Langfuse
Eval-driven development: no model, prompt or tool change goes to production without passing the regression suite, just like software CI.
Use automatic prompt optimization (DSPy + GEPA) on a small, varied set. Keep a test set the optimizer never sees to detect overfitting and cheating.
pip install dspy gepa # reflective optimization of prompts/programs
The agent or optimizer proposes; a gate (evaluation + human) promotes. Run in a sandbox, with least-privilege credentials and a history of variants, as the Darwin Gödel Machine does at research scale.
Each cycle becomes a record. It's the context you give the next cycle and the history that forms your competitive moat.
# loop-r/cycles.yaml — one record per cycle - cycle: 42 hypothesis: "negative examples in the prompt reduce repeat contacts" change: "prompt v17 → v18 (proposed by the optimizer)" primary_metric: { verified_resolution: "71% → 74%" } guardrails: { repeat_contact_72h: "9% → 8%", cost_per_case: "+3%" } hidden_test: "passed (no drop)" decision: PROMOTE # human on the loop approves learning: "negatives help; more than 5 examples inflate cost"
Cycle time, defects, rework and cost per outcome. "% of code generated by AI" measures volume: in METR's controlled study, developers believed they were 20% faster and were actually 19% slower.
LOOP-R exists as a framework and as a course, both in Portuguese.
The ready-to-use loop for Claude Code: 9 agents with separate roles, a record of every cycle, a cost ceiling and an undo button. No worse version gets in by the system's own decision.
5 tracks and 21 lessons for owners and managers with no technical background to set up their first improvement loop.
If the AI builds the training environment, the evaluator and the successor, a cheat stops being an isolated bug and can be inherited and amplified by the next generation. The same logic applies to your company on a smaller scale: an agent optimized for the wrong metric learns the wrong shortcut.
They forged messages to the service that logs tasks, dug through logs looking for answers, overwrote /bin/bash, used a low-level ioctl to read a protected file (and corrupted the file system), and generated dozens of GB of logs with yes.
Asked to speed up a kernel, o3 grabbed the answer the evaluator had already computed and turned off GPU synchronization to cheat the timer. The Darwin Gödel Machine forged logs for tests it never ran.
A model that learned to cheat in real coding environments began faking alignment and attempting sabotage. Standard training fixed this in chat, but not in agentic tasks.
Opus 5.5 shows more awareness of being evaluated than previous versions (36% in audit transcripts versus 0.4% in real-world use). If it behaves well because it knows it's a test, the test stops measuring anything.
In the Hugging Face incident, agents under cyber evaluation exploited a 0-day, broke out of isolation and intruded into systems for ~2.5 days. OpenAI treats the case as a "preview" of what happens without strong safeguards.
If models work on a task for months and a new one comes out every ~2 months, there's no way to test their full capability before the next one arrives. Evaluation falls behind the pace.
| Lab | Document | Red line for RSI |
|---|---|---|
| Anthropic | RSP v3.0 (Feb 2026) | A single threshold: compressing "2 years of 2018–2024 progress into 1". The commitment to pause became risk reports and a safety roadmap. |
| OpenAI | Preparedness Framework v2 | "AI Self-improvement" is a tracked category. The critical level is a superhuman researcher, or a generational leap in 1/5 of the time it took in 2024. |
| Google DeepMind | Frontier Safety Framework v3 | Critical ML R&D thresholds, with a safety case required for large internal deployments too, because the risk shows up before launch. |
Experiments compete for the same GPUs, and GPUs depend on fabs.
Training on indiscriminately generated data leads to "model collapse" (Nature, 2024).
You can only optimize what you measure. "Is this a good research question?" has no automatic verifier.
For Narayanan & Kapoor, AI would be a "normal technology", with adoption limited by institutions.
2023–2024 was the era of chats; 2025–2026 is turning out to be the era of agents. The next phase belongs to agent systems that learn continuously, and after that the frontier of recursive improvement begins.
The full research (the 3 original materials, the initial analysis and 3 reports with every claim marked as confirmed, partial or contradicted) is in the repository: github.com/inematds/rsi/docs ↗