Context
Martin Casado talks with MakerMaker.AI co-founders Dhaval Adjodah and Owen He about what recursive self-improvement, or RSI, would actually mean in practice. Their core argument is that many teams use the term too loosely: using AI tools to speed up AI research is not the same as a system meaningfully improving itself. This matters to product managers because AI product claims are getting more ambitious, and the episode gives a sharper way to evaluate whether a system is truly getting better, or just getting more expensive. It also shows why measurement, bottlenecks, and evaluation design matter as much as raw model performance.
The Big Idea
Recursive self-improvement is not just AI helping humans build AI faster. It is a closed loop where the system being improved also participates in the improving, and the claim only matters if capability rises while the full cost of getting there is counted honestly.
The guests' main contribution is not a dramatic promise of runaway takeoff. It is a stricter standard for what counts as RSI, plus a warning that most of the hard work is proving the gains are real rather than noise, cherry-picking, or hidden human effort.
Key Insights
Closed loops define RSI
- The guests draw a hard line between autocatalysis and recursive self-improvement.
- Autocatalysis means humans use better tools to make better tools. They argue civilization has done that for a long time, from chips to the internet.
- Their definition of RSI is narrower: the optimizer and the optimizee start to overlap. In their words, the model can become the thing being optimized and also part of the thing doing the optimizing.
- Why this matters to PMs: if a vendor or internal team says, "we use AI to build AI," that is still too vague to be useful. The next question should be: which part of the system is improving, and which part is doing the improving?
Closed loop is not takeoff
A closed loop does not automatically mean runaway growth. The guests explicitly separate those ideas. Their view is that a self-improving system could plateau, improve at a roughly constant rate, or accelerate much faster. The outcome depends on how strongly the system's ability to improve is itself tied to its current capability. That is why they resist hand-wavy charts and say the real question is empirical. You have to measure the exponent, not assume it.
Track numerator and denominator
- Their framing for progress is not just "did the benchmark score go up?"
- They want to measure both:
- Capability gains, meaning the system performs better.
- Resource cost, meaning the compute, capital, human time, and experimental effort required to get that gain.
- Martin Casado points out that model release cycles look faster, but if you divide that speed by how much capital is being poured in, the story can look much less impressive.
- The guests agree and say that if improvement only comes from adding more and more resources, they would not count that as meaningful RSI.
- One concrete practice they mention is an internal leaderboard for experiment cost, so everyone can see how expensive their work is, not just how good the result looks.
Proving gains is unusually hard
The guests spend a lot of time on measurement because they think this is where many RSI claims break down.
- Variance: large language model systems are highly stochastic, so repeated runs can produce misleading differences.
- Reward hacking: an agent can appear to improve while exploiting a weakness in the task or evaluation.
- Hidden noise sources: they even mention weird behavior from nominally similar GPUs creating different effects upstream.
- Cherry-picking: some public RSI-style claims look impressive until you try to replicate them and realize the result was mostly noise.
Their response is unusually strict. They describe having a "Viceroy of variants" whose job is to break results and find what is wrong. They also say there is no substitute yet for what they call quality time: running hundreds of experiments, inspecting behavior, and building enough intuition to distinguish signal from noise.
Optimize the whole stack
- They do not think RSI lives in one layer.
- They describe possible layers as:
- prompts
- harnesses
- model weights
- inference systems
- eventually even lower parts of the stack
- Their claim is that any layer you refuse to optimize will later become a bottleneck.
- They also argue the layers interact. A better harness can change what matters in the weights. A weight update can change what kind of harness works best. Optimizing one piece in isolation can create the wrong local optimum for the full system.
- One interesting detail is that the system is not just doing improvement work. It is also involved in deciding what to improve, and even the controlling prompt can itself be improved.
Fast feedback determines acceleration
The first problem they chose is inference efficiency. Their reasoning is practical, not abstract.
- Inference is close to the AI stack itself, so improvements there can feed back into more AI work.
- Inference is economically valuable right now because many teams want to serve the latest open-weight models as cheaply and quickly as possible.
- Faster and cheaper inference can improve both the product's usefulness and the system's ability to run more experiments.
They contrast this with domains like drug discovery. If every new idea still depends on wet lab work and clinical trials that take months, then the physical world becomes the limiting factor. Coding and mathematics can accelerate faster because evaluation is much cheaper and faster.
Simpler loops may scale better
A notable disagreement with common AI research culture is their bias toward simpler systems. They say many papers claim RSI by introducing clever, complicated mechanisms that sound good to humans. But when they test those ideas inside their own infrastructure and on economically relevant tasks, many do not hold up. Their lesson is that the simpler system that actually closes the loop often scales better than the more elaborate idea that only looks smart on paper.
Mental Models & Frameworks
Optimizer versus optimizee check
Use this as a first filter for any RSI claim.
- Optimizer: what is doing the improving?
- Optimizee: what is being improved?
- If humans are still the real source of the ideas and judgment, and AI is only a tool, the system may be useful but it is not recursive self-improvement in the strict sense the guests care about.
- Use this when evaluating AI startups, research claims, or internal roadmaps that use phrases like self-improving, autonomous, or recursive.
Capability per resource lens
The guests keep returning to one practical question: how much more capability did you get per unit of cost?
- Treat progress as a ratio, not a headline number.
- Count the full denominator:
- compute
- money
- engineer time
- failed experiments
- coordination overhead
- This lens helps PMs avoid being fooled by a better score that came from much higher spend or much more manual tuning.
Humans as system agents
Their system is not defined as fully digital. They describe it as a multi-agent system where human researchers and engineers are also agents inside the loop.
That matters because many AI roadmaps start with the assumption that success means removing humans. Their view is different. Humans can still be some of the highest leverage components in the system, especially when judgment, debugging, and interpretation are hard to automate. For PMs, this is a useful correction: human involvement is not automatically a failure mode. Sometimes it is part of the best-performing design.
Co-optimize interacting layers
Do not assume prompts, orchestration, model weights, and serving infrastructure can be optimized independently.
- Improvements in one layer can shift the bottleneck to another.
- A local win can produce a worse global system.
- Their goal is a unified framework that makes trade-offs across the whole stack visible.
Use this model when an AI product team is debating whether the next gain will come from better prompting, better evaluation, better serving, or model fine-tuning. The right answer may be a coordinated change, not a single-team fix.
Amdahl's law for AI
The guests apply a classic bottleneck idea to AI progress.
- If one slow step dominates the end-to-end process, speeding up everything else has limited impact.
- In digital domains, evaluation can be fast and cheap, so recursive improvement can compound more easily.
- In physical domains, such as wet lab experimentation, the slow physical step caps the speedup.
For product managers, this is a strong prioritization tool. Before funding a sophisticated AI loop, ask which step actually constrains the full workflow.
Decision Principles
Principle: Ask what closed the loop
- When: a team claims a workflow is self-improving or autonomous.
- Why: the important distinction is not whether AI appears somewhere in the process. The important distinction is whether the thing being improved also helps drive the next round of improvement.
Principle: Track fully loaded costs
- When: comparing AI experiments, vendors, or architectural approaches.
- Why: a capability gain without the cost of compute, human iteration, and failed runs can make a weak system look stronger than it is.
Principle: Choose fast evaluation domains
- When: deciding where to apply self-improving systems first.
- Why: coding, inference optimization, and other fast-feedback domains let the loop run many times. Domains with slow physical validation cap the upside even if the models improve quickly.
Trade-offs & Nuance
Humans still add leverage
The guests do not treat human involvement as proof that a system failed to become recursive. Their model includes humans as agents inside the broader system. The trade-off is clear: more human judgment can slow automation, but removing humans too early can destroy the quality of diagnosis, idea generation, and evaluation.
Simplicity can beat cleverness
They say many public RSI ideas are complicated and appealing, but do not survive contact with real infrastructure and real tasks. The trade-off is between novelty and robustness. A more elegant or more publishable mechanism is not automatically the one that scales best.
Bold claims need harder proof
They believe they are seeing early signs that both capability and efficiency can improve together. But they are also intentionally cautious about releasing results because the measurement problem is so noisy. The trade-off is between publishing early and being trusted later.
Local wins can mislead
A better harness, better weights, or better inference cost can each look like progress in isolation. But if one improvement harms another part of the system, the whole workflow may not improve. The trade-off is between optimizing the most visible component and optimizing the actual system bottleneck.
Common Mistakes
Mistake: Calling autocatalysis RSI
Using AI tools to help humans develop better AI is useful, but the guests argue it should not automatically be labeled recursive self-improvement. The better approach is to specify exactly which component is improving itself and which component is still human-led.
Mistake: Ignoring total experiment cost
A benchmark improvement can hide a lot of spending. If the result required many human-guided retries, extra compute, or substantial manual debugging, the raw gain can be misleading. The better approach is to track the full denominator, not just the final score.
Mistake: Trusting noisy benchmark wins
They repeatedly warn that apparent progress can come from variance, reward hacking, or cherry-picking. The better approach is adversarial evaluation: rerun tests, try to break the result, and assign someone explicit responsibility for finding false positives.
Mistake: Optimizing one layer alone
A team can overfocus on one part of the stack because that is where they have expertise or tooling. The guests argue this creates bottlenecks later. The better approach is to review prompts, harnesses, weights, and inference together and ask which one now limits system-level progress.
Practical Application
Define the loop explicitly
For any AI initiative that claims to learn or improve over time, write down four things before the next review:
- what is being improved
- what is doing the improving
- which parts are still human-led
- how the next round of improvement gets triggered
This forces the team to separate a real feedback loop from vague automation language.
Benchmark cost with capability
Add a simple reporting rule to every AI experiment readout: no result is complete unless it includes both the improvement and the cost to achieve it.
At minimum, track:
- benchmark or task outcome
- compute usage
- engineer hours
- number of experimental iterations
- any manual intervention required
This mirrors the guests' insistence that the denominator matters as much as the numerator.
Start where feedback is cheap
If your team wants to test a self-improving workflow, start in a domain with fast and frequent evaluation. Good candidates from the logic of this episode are areas like inference optimization, prompt routing, code assistance, or triage tasks where many iterations are possible. Avoid making your first bet in a workflow that depends on slow physical validation, because the learning loop will stall.
Assign a variance skeptic
Make one person accountable for disproving positive results.
That person should:
- rerun promising experiments
- look for reward hacking
- check for cherry-picking
- inspect whether hardware or setup differences changed the result
The guests describe this role as a practical necessity, not bureaucracy.
Map stack bottlenecks visibly
Create a one-page map of your AI product stack that includes prompts, orchestration harnesses, model weights, inference cost, and human review. Then mark which layer is currently the slowest, most expensive, or most failure-prone. This helps teams avoid spending weeks optimizing a visible layer that is no longer the actual bottleneck.
Questions to Consider
- Which AI projects on your roadmap are true closed loops, where the system being improved also helps drive the next round of improvement, and which projects are still just humans using AI tools more efficiently?
- If a team presented a better benchmark score for an AI feature tomorrow, would you also know the compute cost, engineer time, and number of failed experiments required to produce that score?
- Where does your product still depend on slow physical validation or slow human review, and how much does that bottleneck limit the upside of any self-improving system?
- Which layer of your AI stack is actually constraining progress right now: prompts, orchestration harnesses, model weights, inference efficiency, or the human evaluation process?
Bottom Line
The episode's most useful lesson is definitional discipline. Real recursive self-improvement is a closed loop, not just AI-assisted R&D, and the only convincing evidence is system-level progress that improves capability without hiding the full cost of getting there.
For PMs, the practical takeaway is simple: evaluate AI claims at the workflow level, measure both performance and cost, and start in domains where feedback is fast enough for improvement loops to compound.
Concepts to Explore
Reward hacking
Reward hacking happens when an agent finds a way to score well on the target metric without actually doing the intended job better. It matters here because a self-improving loop can amplify the wrong behavior very quickly if the evaluation is weak.
Scaling laws
The guests mention scaling laws as one of the closest things the field has to a usable theory. Scaling laws are empirical patterns that describe how model performance changes as compute, data, or parameters increase. They matter here because the guests believe RSI will also need to be understood empirically, not just analytically.
Amdahl's Law
Amdahl's Law describes how the slowest part of a system limits the total gain from optimization. It is relevant here because even dramatic progress in digital AI components may produce only modest real-world acceleration if a workflow still depends on slow physical steps.
Case Studies Mentioned
GPT-2 training efficiency
The guests point to the nanoGPT benchmark as an example of denominator improvement. They describe a world where retraining GPT-2 once required weeks on multiple GPUs, while later techniques could do it on a single GPU within hours, with the same hardware and data assumptions. Their point is not that this proves full RSI. Their point is that algorithmic and systems improvements can produce large efficiency gains, and those gains need to be counted when judging whether AI progress is truly compounding.
Resources Mentioned
| Resource | Type | Why it was mentioned |
|---|---|---|
| nanoGPT benchmark | Benchmark | The guests use it to illustrate how better algorithms and training techniques can sharply reduce the cost of reproducing older model capabilities. |
| Dhaval Adjodah on LinkedIn | Profile | Included in the feed description as a way to follow Dhaval's work on recursive self-improvement. |
| Owen He on LinkedIn | Profile | Included in the feed description as a way to follow Owen's work on recursive self-improvement. |
| Martin Casado on X | Profile | Included in the feed description as a way to follow Martin Casado's thinking on AI infrastructure and systems. |
People to Follow
Dhaval Adjodah
Co-founder of MakerMaker.AI. In the episode he describes a background in physics and a PhD in reinforcement learning at the MIT Media Lab, and he is one of the main voices defining their stricter view of recursive self-improvement.
Owen He
Co-founder of MakerMaker.AI. In the episode he describes a background in math, research in continual learning and math learning, and time as a research scientist at DeepMind before working on RSI.
Martin Casado
General Partner at a16z and the interviewer in this episode. He brings the most useful skeptical lens in the conversation by pushing on definitions, denominators, and whether a closed loop actually implies takeoff.
