An Optimization Perspective on Recursive Self-Improvement

TL;DR

• Be strict about the definition. Recursive means each step's improvements drive the next round; self means the system improves itself, not some other target. Common usage is simultaneously too permissive (calling ordinary iterative loops RSI) and too restrictive (insisting only LLM parameter updates count).
• Shift from LLM-centric to systems-oriented. Treating the LLM as one component of a broader system opens up improvement possibilities you'd otherwise miss — and tends to be faster and cheaper. Poetiq's loop costs one inference run per step, not one training run.
• Self-optimizing optimizers. Start with a general-purpose optimizer (no specialized signals like gradients; it only needs measurable feedback from the target). Point it at a task and you have plain iterative optimization. Point it at itself and you have RSI. The only two requirements: the optimizer must be general-purpose, and it must report feedback on its own performance.
• Results: the meta system sets state-of-the-art fully automatically — zero human intervention — across public benchmarks, and on half of them it did so using older, cheaper models than the previous record holder. Hence their claim that "benchmarks are dead" — not useless, but of limited value in the presence of a genuinely self-improving system.

Key Points

What actually counts as RSI (~02:11–02:13)

Poetiq is a roughly 18-month-old startup built entirely around recursive self-improvement — "AI that improves itself." Ten scientists and engineers, mostly ex-Google DeepMind, plus Apple, Microsoft, Amazon, ByteDance. Early results set state-of-the-art on reasoning, knowledge extraction, and coding.

He unpacks the acronym deliberately, because two of the three letters do all the work. Recursive: improvements at each step drive the next round. Self: the target of improvement is the system itself. Improvement: everyone's doing some version of that.

The pedantry has a purpose. Common usage is too permissive — labeling standard iterative improvement loops as RSI — and too restrictive — insisting RSI only counts when you're updating an LLM's parameters. The latter misses that a lot of other pieces of an intelligent system can be improved quite effectively.

Why does it matter? Because real RSI compounds, and human-driven improvement doesn't: humans don't get inexorably smarter while improving models, but RSI systems do. That's why he calls it the most important frontier in AI research and the shortest path to superintelligence.

The landscape: two axes (~02:13–02:16)

Y-axis: cheap at the top, expensive at the bottom. X-axis: not-really-RSI on the left, genuine RSI on the right.

• Lower right (expensive, genuine RSI): where the best-funded efforts live — Anthropic, OpenAI, Google. This is the LLM-centric picture most people have of RSI. Genuine, but every step requires training an LLM from scratch.
• Upper right (cheap, genuine RSI): where Poetiq places itself, and not arbitrarily — their loop does compound, and each RSI step costs only an inference run. Neighbors: Darwin Gödel Machine and SICA (both primarily targeting coding), and the MiniMax harness (trains on some of its own generated data). All genuine and cheap, just narrower.

The same split read horizontally: the bottom half is LLM-centric, the top half is systems-oriented — viewing the LLM as just a component of a broader system worth improving.

He then diagnoses two prominent approaches:

• Anthropic's "AI that builds itself": put a version of Claude inside Claude Code, then humans + Claude Code improve Claude. Partial RSI — Claude is both the thing improved and part of the improver, but there are humans in the loop and he doesn't count them (neither does Anthropic). The fix: remove the humans, which he thinks is where they're headed and maybe what they're worried about.
• The automated AI scientist / auto-research pattern: generate a hypothesis → implement it → measure it → write a paper → file it in a knowledge store. Usually not RSI, because it isn't targeting a piece of its own system. The fix is equally simple — target the LLM used inside the loop — but that makes it far more expensive than what most people run today.

Poetiq's approach: self-optimizing optimizers (~02:16–02:19)

1. Start with a general-purpose optimizer — one that relies on no specialized signals like gradients, requiring only measurable feedback from the target. This is more general even than black-box optimizers like hill climbing, because the feedback need not be quantitative.
2. Point it at an optimization target. Feedback can be conventional (accuracy, cost) or unusual (rubric evaluations, reasoning targets). This is still just iterative optimization.
3. Point it at the optimizer itself. Now the optimizer is optimizing the optimizer that's optimizing the target — and that is RSI.

Two requirements only: general-purpose, and able to report on its own performance. Since every optimizer can do the latter, there's no obstacle. He's explicit that this is very different from saying the optimizer is Adam or SGD — that would not work.

The result is the Poetiq meta system. Every task it optimizes helps it optimize itself into a more powerful optimizer, and because it's general-purpose it can be aimed at any part of the meta system as well as at any measurable task — benchmarks, customer data, whatever.

Empirical results and "benchmarks are dead" (~02:19–02:21)

Their blog post declaring benchmarks dead isn't a claim that benchmarks are useless — it's that in the presence of a properly recursive self-improving system, static benchmarks have limited value, because the system gets state-of-the-art fully automatically on every benchmark they've turned it on. Zero human interventions, usually quite quickly.

The most interesting detail in the results table: the benchmarks span a wide variety of domains they'd never worked on before, and on half of them they hit SOTA using older, cheaper models than the previous record holder — which was typically Fable 5.

What's next: less benchmark focus, more work with early customers across a variety of domains. His closing framing: the next phase transition in AI will come from a system that invents its own improvements, and Poetiq is deliberately casting a wide net for it by taking the optimization perspective on RSI and using it to optimize everything, optimizers included. (He also noted they're hiring.)

Quotes

"Recursive means that the new improvements at each step are going to drive the next round of improvements. And self — the system really is going to improve itself, not some other target." (~02:11)

The definitional baseline the whole taxonomy rests on.

"Humans don't become inexorably smarter while improving models, but RSI systems can." (~02:12)

Why RSI compounds and human-driven improvement doesn't.

"In the case of Anthropic, we can just get rid of the humans. They've kind of indicated that that's where they're headed and that's maybe something that they're worried about." (~02:16)

The one-line fix that turns the Claude Code loop into pure RSI, delivered dryly.

"The next phase transition in AI is going to come from a system that invents its own improvements." (~02:20)

The closing thesis.