Dead Reckoning
Before GPS, before satellite navigation, before any fixed reference point you could trust, sailors estimated their position the hard way. You logged your starting point, tracked your heading, measured your speed, and noted every change. No single observation told you where you were. The position emerged from the accumulated record: each small entry individually uncertain, collectively reliable enough to cross an ocean. You committed to a best estimate, acted on it, and updated when new information arrived. The method had a name: dead reckoning.
It worked not because it was precise, but because it was disciplined. The navigator who waited for certainty before committing to a position was the navigator who never arrived. The one who tracked the heading, logged the small signals, and revised continuously was the one who arrived.
This is how transformative capabilities arrive: not a single moment you can point to, but hundreds of small updates and quiet capability jumps that most people process as noise. A model that handles a longer context window. A benchmark quietly crossed. A coding assistant that stops feeling like a toy and starts feeling like a colleague. None of these moments feel like history. All of them are.
The debate about what to call where all of this is heading is real and worthwhile, and it won't be settled anytime soon, which is fine, because it never really is. Superintelligence. AGI. Transformative AI. Pick your term: each has advocates, each has detractors, and none has a locked definition. Did we ever decide what \"the cloud\" was? Do we agree on what a photograph is now that every phone applies computational processing before the shutter sound even fires, and AI afterwards? Definitions are hard to pin down at the best of times, and significantly harder when the thing being defined keeps changing. That doesn't make the exercise pointless. Taking a swing at a definition is useful: it forces precision, surfaces assumptions, and gives you something to update as the evidence changes.
But a settled definition was never the prerequisite for navigation. The prerequisite is reading the small signals honestly, logging them, and asking what heading they imply.
Right now, three separate trails of breadcrumbs are converging. Here's what they are, where they've come from, and why their intersection is worth tracking.
The fuel is changing
For most of AI's recent history, the binding constraint on what models could do was data: you needed more of it, better labeled, more carefully curated. Compute mattered, but data was the ceiling. That relationship is inverting.
One concrete signal of this: a research project called NanoGPT Slowrun runs a deliberately inverted benchmark. The data budget is fixed (100 million tokens, no more) and compute is unlimited. Contributors compete to extract the most from that fixed supply, with no time or hardware constraints. Within days of launch, community contributions had pushed effective data efficiency to 5.5 times the baseline. The researchers estimate 10 times is reachable soon, and 100 times within a year. Whether those numbers land precisely is secondary. What matters is the revealed dynamic: flip the constraint, and progress accelerates in a single direction.
This is not an isolated project. Researchers across the field are increasingly designing for a world of practically infinite compute and scarce data, building learning algorithms that extract far more signal from far fewer examples. The results are arriving faster than most forecasts implied, compounding through open community contributions in ways that traditional lab-bound research doesn't. Targets that seemed distant at the start of a week look reachable by its end.
This matters because once compute becomes the primary input rather than data, the ceiling lifts in a qualitatively different way. Data is bounded by what humans have already done. Compute compounds on itself, through hardware improvements, capital investment, and algorithmic gains that stack on each generation of both. One has a far higher ceiling, and only one gets reliably cheaper each year.
Generality is a side effect, not a design goal
The second trail follows directly from the first. When you build models in compute-constrained rather than data-constrained regimes, something unexpected happens: generality increasingly falls out as a consequence of scale, not as something anyone specified.
The clearest recent illustration comes from Standard Intelligence's FDM-1 project. Researchers trained the model on eleven million hours of internet video: screen recordings, coding streams, design sessions, the accumulated digital behavior of people working at computers. The goal was computer use. The result was something harder to categorize. The model learned to navigate complex software, to execute long sequences of actions across multi-hour workflows, to do basic CAD modeling and security testing. So far, that's impressive but bounded. Then the team fine-tuned it on less than one hour of driving data, and, in a constrained demonstration under supervision, it drove a car around a block in San Francisco.
Nobody designed a self-driving feature. Nobody included driving in the training objective. A model trained on screen recordings crossed a domain boundary that wasn't in the specification and transferred. That's not a benchmark result. That's a different kind of thing.
This is the pattern that keeps recurring as models move from data-constrained to compute constrained development. Capability trained in one domain generalizes to another without anyone planning for it. The models aren't being designed to be general. They're becoming general because generality is what falls out when you scale compute against a sufficiently broad input.
General models are proving useful in the real world
The third trail is the one most people are already standing on, even if they don't think of it that way. General models are proving useful not in research environments, not on benchmarks, but in the actual work of people who have real things to get done.
Claude Code is the most visible current example: not a coding assistant that autocompletes lines, but a system that takes a goal and pursues it autonomously across a codebase, making decisions, running tests, correcting itself. General computer use is following the same trajectory, with models that can navigate interfaces, execute workflows, and complete tasks that until very recently required a human to be present at a keyboard. These aren't demos. They're in production, handling real work, and the rate of improvement is not slowing down.
The significance of this third trail is easy to underestimate. Research breadcrumbs are interesting; useful breadcrumbs compound. Once a general capability proves itself in real work, it attracts investment, use, feedback, and iteration. The loop tightens. What's useful today becomes the baseline for what's expected tomorrow, and the gap between expectation and capability closes faster than the previous cycle.
Three lines, one direction
What makes the current moment different from earlier periods of AI progress is not any single one of these trails. It's that they're converging.
The resource constraint shifting to compute means the fuel supply is no longer the binding limit. The emergence of generality from compute-bound training means the models being built are increasingly capable across domains rather than within them. And the proof of usefulness in real work means the feedback loop has closed: these capabilities are now being stress-tested against actual complexity, not synthetic benchmarks, and they're holding up.
When three independent lines of progress reinforce each other, the pace of the combined movement is not additive. Each trail makes the others more productive. More efficient training produces more general models, faster. More general models mean broader usefulness. Broader usefulness means sharper feedback about where the limits actually are, which feeds back into training. The breadcrumbs are coming faster, and they're no longer running in parallel.
None of this guarantees smooth progress. Real bottlenecks remain: in alignment, in energy infrastructure, in hardware supply chains, in the governance frameworks that don't yet exist, and in the organizational absorption rates of companies and institutions that are still figuring out what to do with the capabilities already in their hands. These are not trivial constraints. But none of them currently appear to be tightening faster than the underlying capabilities are improving. The heading holds, even if the speed is uncertain.
Which brings us back to the question of what to call the destination. If you define superintelligence as systems capable of outperforming humans across most cognitively valuable tasks, not a perfect definition but a working one, then the three trails described here are pointing toward it, not arriving yet, but pointing unmistakably. The distance is genuinely unknown. But dead reckoning doesn't require knowing the distance. It requires honest position estimates, regular updates, and the discipline to act on your best current read rather than waiting for the landmark that may not appear until you're already there.
Most people are experiencing this as a series of product updates. An assistant that writes better than it did six months ago. A tool that can hold a research thread across an afternoon. The improvements feel incremental because they arrive incrementally, which is exactly how structural shifts always feel from inside them. The sailors who first mastered dead reckoning didn't experience a revolution in navigation. They just kept logging the same small signals, updating their position, and arriving where they intended to go, until one day the method had quietly crossed an ocean, and the world was a different size than it used to be.
The lines are no longer parallel. They're converging. The discipline is the same as it always was: log the signals, track the heading, update your estimate. Dead reckoning assumes a navigator distinct from the vessel. For now, we are still the ones doing the reckoning. The navigator who waits for certainty doesn't avoid risk. He compounds it.