You can scale your way to intelligence: How to achieve AGI

Sam Altman just predicted AGI by 2025 and the timeline might not be completely crazy.

In a recent interview with YC's Garry Tan, Altman made his boldest claim yet: the path to AGI is "basically clear" and primarily an engineering challenge rather than a scientific one.

The key insight appears to center around OpenAI's reasoning model (O1) and its scaling properties. While previous models showed diminishing returns with further scale, O1's architecture seems to have different characteristics.

Altman described a particularly striking demonstration: a team built a system that could iteratively improve an airfoil design from non-functional to achieving competitive lift. This wasn't just optimization - it represented genuine innovation through iterative improvement.

As Altman noted in the interview: "I had been telling people for a while (...) that the level three to level four jump was somehow going to be much harder and require some medium-sized or larger new ideas and that demo and a few others have convinced me that you can get a huge amount of innovation just by using these current models in really creative ways."

The Technical Case

The strongest argument for Altman's timeline comes from the emergence of tool use and reasoning capabilities. Current models can:

1. Write code to solve novel problems
2. Use that code to build tools
3. Compose those tools to solve increasingly complex tasks
4. Evaluate and improve their solutions

This creates a potential feedback loop we haven't seen before. Unlike previous scaling laws that focused on raw parameter count and training data, this new paradigm suggests a different scaling mechanism: the ability to build and compose tools programmatically.

OpenAI researcher Clive Chan put it succinctly: "Maybe there's another wall after this one, but for now there's 10xes as far as the eye can see." His colleague Noam Brown backed this up, noting that Altman's timeline "matches the ~median view of OpenAI researchers on the ground."

Why This Time Might Be Different

Remember how MNIST->ImageNet->Stable Diffusion progression worked? Each jump wasn't just about more parameters or data; it was about fundamental capability unlocks that enabled new scaling laws. We might be seeing something similar with reasoning models.

The traditional objection to rapid AGI timelines has been: "You can't just scale your way to intelligence." But what if you can scale your way to building better scaling mechanisms? That's essentially what tool use enables - models that can create their own leverage.

The Infrastructure Question

The biggest counterargument to 2025 isn't theoretical - it's practical. Even if the path is clear, can we build enough compute infrastructure that quickly? My back-of-the-envelope math:

# Assuming current scaling trends
compute_required = current_compute * (capability_jump ** 2.7)  # Historical scaling law
# For 10x capability jump
required_increase = 10 ** 2.7  # ~501x more compute

This suggests we'd need roughly 500x current compute capacity. Possible? Maybe. OpenAI has been quietly building massive data center capacity. Microsoft just announced a $100B infrastructure investment.

Why I'm Still Skeptical (But Less Than Before)

The core blocker isn't theoretical or even computational - it's integration. Getting from reasoning to reliable autonomous action is a massive engineering challenge. Current models can write perfect code but still make basic logical errors in their long-chain reasoning. Solving this feels like more than just an engineering challenge.

However, O1's architecture might offer a solution: instead of trying to make one model do everything perfectly, build systems that can check and correct their own work. We're already seeing this with tool use - models that can write tests, verify results, and iteratively improve solutions.

What I'm building

Delegate tasks. Get software.

Give Vroni a GitHub issue, bug report, spec, or rough idea. It reads the repo, plans the change, writes code, runs checks, and works toward a review-ready pull request.

Take a look at vroni.com