What Is RSI in AI? Recursive Self-Improvement, Explained (2026)

RSI in AI stands for recursive self-improvement: an AI system helps build a better version of itself, and that better version is in turn better at building the next one. The "recursive" part is what separates it from ordinary progress. Every software team uses yesterday's tools to build tomorrow's; RSI is the specific case where the thing being improved is also the thing doing the improving, so each gain can feed the next one.

If you landed here from a search for "RSI meaning", note that the acronym has two unrelated common expansions outside AI: the Relative Strength Index used in trading charts, and repetitive strain injury. Neither applies when the context is OpenAI, Anthropic, model training, or evals.

Where the term comes from

The idea is older than modern machine learning. In 1965 the statistician I. J. Good wrote that an "ultraintelligent machine" could design even better machines, producing what he called an intelligence explosion. AI safety writers in the 2000s gave the mechanism its current name, recursive self-improvement, and for two decades it was mostly a thought experiment about where the curve might go.

What changed is that the inputs to model development became things models can now produce. Training data can be generated and graded by a model. Training and evaluation code can be written by a coding agent. Experiments can be proposed, run, and summarized by an agent with a GPU budget. Once those steps are partly automated, the question stops being philosophical and becomes operational: how much of the next model did the current model build?

Weak RSI and strong RSI

It helps to split the term in two, because most arguments about RSI are two people meaning different things.

• Weak RSI (AI-assisted AI development). Humans still run the program, but models do a growing share of the work: writing the data pipeline, labelling or ranking outputs, generating synthetic training examples, debugging training runs, drafting experiment reports. This is happening now. Techniques like reinforcement learning from AI feedback, where a model rather than a human grades responses, are an early, well-documented version of it.
• Strong RSI (autonomous self-improvement). A system proposes changes to its own architecture, training, or code, applies them, measures the result, and repeats, with each round making the next round faster. This is the version behind intelligence-explosion scenarios. It has not been shown to work, and there are good reasons it may stall: compute, data, and evaluation all have hard limits that a smarter model does not remove.

When a lab says it is "pursuing RSI", it is describing weak RSI as a research direction and signalling it expects the strong version to become relevant. When a critic says RSI is hype, they are usually attacking the strong version.

What OpenAI and Anthropic said in 2026

On September 6, 2026, OpenAI published two pieces, a research acceleration post and Chief Scientist Jakub Pachocki's essay "An Alien Mind", that together named RSI as the company's central research focus. The acceleration post used the acronym without expanding it, which is part of why so many people searched for its meaning that week. Our coverage of OpenAI's RSI push walks through both posts and what they imply for teams shipping on the API.

Anthropic has been more concrete about the weak form: according to The Washington Post, Claude is now doing substantial work on its own successor, including writing components and finding bugs. We covered that in Anthropic is using Claude to build the next Claude. The practical limits of the same loop show up in a smaller experiment, where Claude Code was pointed at the Claude app's own codebase and succeeded on contained changes while quietly falling apart on ones that needed the whole system in view.

How RSI is measured: what "RSI evals" are

You cannot manage what you do not measure, so labs track self-improvement capability with evaluations that look like AI research work. Three public examples:

1. MLE-bench (OpenAI, 2024). Agents compete in a set of Kaggle machine learning competitions, end to end: read the task, build a pipeline, train, submit. The score is how many competitions reach a medal-level result.
2. PaperBench (OpenAI, 2025). Agents try to replicate published machine learning papers from scratch, and are graded against detailed rubrics written with the papers' authors.
3. RE-Bench (METR, 2024). A set of open-ended ML research engineering tasks with human expert baselines, built to compare how agents and people perform when given the same time budget.

OpenAI's Preparedness Framework lists AI self-improvement as a tracked risk category, and benchmarks like these are how a lab would notice the threshold approaching. When people search "RSI evals OpenAI", this is the family of tests they are looking for. The important property for everyone else: these evals measure a moving target, and a benchmark that is hard this quarter is often saturated a year later.

What RSI changes if you build on LLMs

You do not need a view on the intelligence explosion to be affected. If models are improving their own research process, the gap between meaningful model changes shrinks, and the changes are harder to predict from release notes. Four practical consequences:

• Pin model versions in production. Calling an unversioned model alias means accepting whatever behaviour ships next, and lineups now turn over within months: the GPT-5.6 family arrived in three tiers and became a default inside Microsoft 365 Copilot on day one. Pin, then upgrade on purpose.
• Keep a regression set and rerun it on every upgrade. Thirty to a hundred real inputs with known good outputs is enough to catch most prompt regressions. It is the same discipline our silent agent failures guide recommends for agents, applied to model swaps. For agents, a language world model such as Qwen-AgentWorld-35B can stand in for live tools during these runs, once you have checked its predictions against real responses.
• Expect evals to age. If your internal eval is a fixed set of questions, a stronger model will eventually ace it without being better at your actual job. Refresh a slice of it each quarter from recent production cases.
• Audit prompts that lean on human analogies. Instructions like "use common sense" or "think like an expert would" depend on the model reasoning the way people do. Pachocki's essay argues that this assumption gets weaker over time; explicit criteria hold up better than appeals to intuition.

A prompt for checking a model upgrade

When a new model version lands, this prompt turns your regression run into a decision instead of a vibe check:

You are reviewing a model upgrade for a production prompt.
<prompt>[paste the production prompt]</prompt>
<old_outputs>[paste 10 to 30 outputs from the pinned version]</old_outputs>
<new_outputs>[paste outputs for the same inputs from the new version]</new_outputs>
For each pair, say whether the new output is better, worse, or equivalent against these criteria: [list criteria]. Then list any change in format, length, refusals, or tone that a downstream parser or reader would notice. End with a recommendation: upgrade, upgrade with prompt changes (say which), or hold.

The last line is the point: the output is a decision you can act on, with the prompt edits that would make the upgrade safe.

The honest uncertainty

Nobody knows how far the loop goes. The optimistic case is that each model generation shortens the next one's development and capability compounds. The sceptical case is that the hard constraints, compute, high-quality data, and the difficulty of evaluating research that exceeds the evaluator, slow the loop to something that looks like ordinary fast progress. Both camps agree on the near-term consequence for builders: plan for models that change more often, and build the tests that tell you what changed.