What if the next major jump in AI capability isn’t from a new architecture or a bigger training run, but from AI quietly accelerating the AI research loop itself? At AI Tech Inspire, that’s the thread we pulled on after a public analysis from METR’s Ryan Greenblatt suggested that automation in AI R&D may already be delivering outsized compounding effects—earlier than many expected.
Key facts at a glance
- Ryan Greenblatt (of METR) reacted to a public report on AI R&D automation (often called
RSI, for recursive self-improvement). - The report estimates ~2x acceleration in overall AI progress attributable to automation right now.
- Greenblatt’s prior “AI 2027” modeling placed this level of acceleration around March 2027; current signals suggest the effect is arriving months earlier.
- Greenblatt previously expected only ~1.15x–1.3x speedup in 2026 and says he was “seriously wrong” on that point.
- He has not seen the unredacted report; substantial evidence is redacted, so some conclusions hinge on trust in the authors.
- Using public modeling, he estimates that to produce a 2x overall acceleration, AI software R&D itself (algorithms and data) likely needs to be sped up by roughly ~4.5x compared to no automation.
- Two drivers for the higher figure: only ~2/3 of overall progress comes from software (the rest from compute scaling), and software progress faces diminishing returns (~2x slow-down per “year” of software progress if inputs stayed fixed).
- He infers ~0.35–1.0 years of extra software progress already showing up in models (geometric mean ~0.6), yielding ~
3 * 2^0.6 ≈ 4.5. - He frames this as a notable update toward possible ASI within 1–2 years, while noting he cannot share all-things-considered timelines due to potential confidential information.
- He urges less redaction to reduce reliance on trust in author judgment.
Why this matters to builders
For developers and engineers, the claim isn’t merely a headline—it’s an operational prompt. If AI automation is already doubling overall progress and pushing software R&D velocity toward ~4.5x, then timelines for capability jumps, safety work, and integration plans likely compress. Product roadmaps that assumed linear research throughput may be off by a wide margin. The toolchains you choose, and the degree to which you automate your own experimentation loop, could now be a strategic advantage rather than a nicety.
“This report on AI R&D automation (RSI) is a big update towards ASI within 1–2 years.”
The strong claim invites scrutiny. But even as a working hypothesis, it suggests teams that industrialize their research loop—proposal, implementation, evaluation, reflection—can surf this acceleration rather than be surprised by it.
RSI, demystified: AI that helps build better AI
RSI doesn’t necessarily mean agents autonomously redesigning their own weights overnight. In practice, today’s AI R&D automation looks like:
- Code synthesis and refactoring for experiments in PyTorch or TensorFlow.
- Automated literature triage, ablation planning, and write-ups.
- Evaluation harnesses that generate test suites and adversarial cases.
- Data engine orchestration: curation, filtering, labeling, and synthetic data generation.
- Hyperparameter and architecture search guided by learned heuristics.
- Optimization passes targeting kernels and ops with CUDA-aware cost models.
If you’ve stitched together Hugging Face datasets, a retrieval pipeline, an LLM agent, and a scheduler to run experiments in parallel, you’re already flirting with RSI. Add a feedback loop that prunes unpromising directions and amplifies the promising ones, and you’re building a lightweight research accelerator.
Inside the ~4.5x software R&D estimate
Greenblatt’s back-of-envelope logic is straightforward but consequential:
- Suppose only ~2/3 of capability gains come from algorithmic/data improvements (software), and the rest from larger training runs (compute). Then a 2x overall acceleration implies roughly ~3x faster software progress alone.
- Now account for diminishing returns: if each “year” of software progress makes the next “year” twice as hard (holding inputs fixed), then incorporating ~0.6 years of extra software progress implies an additional factor of
2^0.6 ≈ 1.52. - Multiplying gives
3 * 1.52 ≈ 4.5—the rough estimate for how much automation may be accelerating AI software R&D right now.
Is the math ironclad? No. It rides on several assumptions: the software share of progress, the shape of diminishing returns, and the inferred “extra” software progress since the prior trend. Greenblatt explicitly flags that some evidence is redacted in the public report, which means readers are leaning on author judgment. Still, the math—paired with the observation of faster benchmark progress—is a concrete way to reason about what a measured 2x overall speedup might imply under the hood.
Comparisons and context
We’ve seen individual tools produce eye-popping productivity numbers before: code assistants that double iteration speed, reproducible pipelines making evaluation near-instant, or image models like Stable Diffusion cutting concept cycles from days to hours. But those are local speedups. The claim here is systemic: that the end-to-end AI research engine is now meaningfully faster.
In prior eras, progress leaned heavily on scaling laws and infrastructure upgrades (think optimized kernels, better compilers, or larger GPU clusters). Frameworks like PyTorch and TensorFlow standardized the substrate; Hugging Face helped socialize best practices and checkpoints; CUDA kept pushing FLOP efficiency. Today, the interesting twist is that general-purpose models (e.g., families of GPT) are being placed inside the research loop itself—as planners, coders, readers, evaluators, and red-teamers. That puts a multiplier on how quickly good ideas are generated, tested, and integrated.
If you’re a developer: practical moves to consider
- Automate your micro-research loop. Capture the cycle—
propose → implement → test → reflect—in scripts and agents. Use structured outputs (JSON schemas) and persistent logs for scoring ideas and avoiding repeats. - Treat evals as first-class code. Build task suites that evolve with your system: auto-generate adversarial cases and keep a rolling difficulty ladder. Consider periodic external checks (e.g., MLPerf style discipline) to avoid overfitting.
- Upgrade your data engine. Automate filtering, dedup, and targeted synthesis. Link curation decisions to downstream metrics so your agent can learn which data transformations actually move the needle.
- Exploit low-latency iteration. For model variants (e.g.,
LoRAadapters), push toward minutes-long feedback loops. Cache everything; pre-compile hot kernels. - Institutionalize “AI pair researchers.” Encourage teams to use model assistants for literature search, ablation design, and critique. Standardize prompts and checklists. A small boost multiplied across dozens of decisions can mirror the reported macroscale speedup.
As you wire this up, ergonomics matter. Even small touches—like binding Ctrl+Enter to launch your next experiment batch, or autosurfacing the last three failed hypotheses—compound over time.
Risks, caveats, and how to sanity-check
- Redacted evidence. The public report leaves gaps; some inferences rest on trust. Mitigate by reproducing local versions of the analyses you can access.
- Attribution is hard. A faster benchmark curve could reflect more compute, better data, or broader community focus—not only RSI. Track your organization’s contributions across all three inputs.
- Diminishing returns are real. Even if the ~4.5x figure holds today, the gradient may get steeper. Design your automation to retool itself as regimes shift (e.g., from data-limited to compute-limited).
- Safety debt accrues faster. If capability ramps compress from years to quarters, invest now in evaluation breadth, red teaming, and rollback plans.
Greenblatt also notes a conflict-of-interest style caveat: as someone who may encounter confidential information, he’s not offering all-things-considered timelines. That stance is worth mirroring—teams should separate internal measurements from public narratives and be clear about what is and isn’t evidenced.
What this could mean for timelines
The “AI 2027” framing suggested that a similar acceleration wouldn’t land until around March 2027. If the public report’s 2x overall speedup is indeed attributable to R&D automation, and it’s appearing months earlier than that scenario, then planning horizons for both capability and safety work shrink. That doesn’t prove a software intelligence explosion is imminent—but it nudges prudent teams to behave as if compounding is already in flight.
Questions to ask your team this week
- Which parts of our research loop are still manual, and what’s the smallest agent we can ship to relieve them?
- Are our evals rich enough to detect overfitting from automated idea generation?
- If we got a surprise ~2x capability jump in six months, what would break in our stack, process, or safety posture?
- What metrics would convince us our own RSI setup is actually contributing to outcomes (not just motion)?
At AI Tech Inspire, the takeaway is simple: even with redactions and caveats, the shape of this update points in a clear direction. Teams that productize their research loop—treating automation as a core capability, not a convenience—are likely to capture more of the upside if the reported acceleration persists. Whether the true number is 3x, 4.5x, or something else, the strategic move is the same: turn scattered scripts into a disciplined, measurable AI R&D engine—and let compounding do the rest.
Recommended Resources
As an Amazon Associate, I earn from qualifying purchases.
