True intelligence, the kind that genuinely understands rather than statistically mimics, may require something current AI research largely ignores: mortality. Not a reset button or a training penalty, but a mechanism that raises the ultimate stakes for an agent while irreversibly erasing everything it learned from the information pool when it fails. Instilling that same existential weight into artificial systems, so it shapes every decision, every learned behavior, proves both prohibitively expensive and technologically unfeasible.
Nature spent roughly 3.3 × 10^43 operations over 500 million years to evolve vertebrate intelligence. Our largest GPU clusters can deliver 9.5 × 10^28 operations over a decade. We are 350 trillion times short. Even with the Baldwin effect accelerating evolution 1,000×, we remain 350 billion times short, a gap of eleven orders of magnitude that no plausible near-term improvement closes.
Every language model trained on humanity's collected wisdom can reproduce eloquent descriptions of fear, pain, survival, and extinction because it has absorbed millions of examples of such descriptions. These systems exhibit capabilities that surprised even their creators: in-context learning, chain-of-thought reasoning, apparent planning. We should not dismiss these emergent behaviors, but we should also not mistake surprising capabilities for understanding. A system can exhibit remarkable behaviors while remaining fundamentally a predictor of likely next tokens. The question is not whether these systems are impressive, they plainly are, but whether scaling prediction leads to understanding or merely approaches it asymptotically without arriving.
The current AI revolution rests on a seductive premise: that intelligence emerges from pattern recognition in vast corpora of text. We've poured billions into scaling transformer models, expanding context windows, and optimizing inference, producing systems that dazzle with their fluency and occasionally deceive us into mistaking reflection for understanding. We've built Plato's cave in silicon, training models on shadows of intelligence without ever glimpsing the fire. The gap between processing and experiencing cannot be closed by adding more GPUs or training on more tokens. It's a gap of kind, not degree.
The necessity of mortality
Evolution operates through a mechanism so brutal and so elegant that we often fail to appreciate its full implications for intelligence. The textbook account presents variation and selection as complementary forces: organisms vary through mutation, and those variations face selection pressure from their environment. Beneficial mutations propagate; harmful ones disappear. This is accurate but incomplete, because it glosses over what makes selection pressure actually work. Selection requires consequences, and in biology, the ultimate consequence is death. An immortal organism experiencing resource scarcity faces inconvenience, perhaps discomfort, or perhaps neither, given eternity to wait as environments shift and constraints ease. Mortality isn't a side effect of evolution; it's the enforcement mechanism that makes evolution possible.
Without mortality, selection pressure collapses, but the deeper problem is motivational rather than mechanical. One might object that resource scarcity alone creates selection: immortal organisms competing for limited resources would still eventually evolve to be intelligent. But this misses what mortality actually provides. Death doesn't just remove failed variants from the population; it creates the urgency that makes optimization matter.
Consider an immortal agent facing a choice between efficient and inefficient behavior. The inefficient path wastes resources and time, but time is infinite. Why optimize when you can wait? Why pursue "better" when you exist forever? It seems reasonable to assume that intelligent immortal beings can only evolve from mortal ones, or were always intelligent through some other process we're unaware of.
Finitude is the driver of intelligent life. It creates the scarcity that makes moments matter, the urgency that makes action preferable to waiting, the horizon that makes "better" meaningful rather than merely different. An agent that will exist forever has no reason to prefer pleasure now over pleasure later, no reason to optimize for efficiency when inefficiency merely delays rather than prevents, no reason to act decisively when deferral costs nothing. Evolution requires not just that failed variants disappear but that successful variants are driven to succeed, and that drive comes from the pressure of limited time. Mortality creates the temporal horizon against which all optimization makes sense.
This explains why evolution requires asymmetry: beneficial variations must propagate while harmful ones disappear. Mortality creates this asymmetry not just by removing the unfit but by making fitness matter to the fit.
The evolutionary history of intelligence on Earth bears this out with stark clarity. From the Cambrian explosion roughly million years ago through the emergence of Homo sapiens, every step toward greater cognitive capability occurred in organisms subject to intense selection pressure enforced through mortality. Early vertebrates developed rudimentary learning mechanisms because the ones who couldn't died before reproducing. Mammals evolved larger brain-to-body ratios because the ones who couldn't adapt to changing environments went extinct. Primates developed theory of mind because the ones who couldn't navigate complex social hierarchies lost access to mates and resources. At every stage, death culled the less capable, and the survivors' descendants carried forward the genetic substrate for incrementally better cognition. This process required not millions but billions of organism-lifetimes, each one a test case, most of them failures, the rare successes propagating their advantages into the next generation's starting point.
Current language models stand entirely outside this process. They optimize against loss functions, certainly, and those loss functions create pressure toward better predictions. But the pressure is abstract, mediated through gradient descent on parameters that have no survival value because survival is not at stake. When a language model produces a poor prediction, its weights adjust by infinitesimal amounts in directions that reduce future error. When an organism makes a lethal mistake, it dies, and its particular combination of traits disappears from the population forever. These are not equivalent pressures. The language model receives feedback proportional to error magnitude; the organism receives binary feedback with ultimate stakes. The language model updates continuously across all parameters simultaneously; evolution updates through discrete generational steps, preserving only what works well enough. Most critically, the language model processes descriptions of survival challenges without ever facing consequences that would make those descriptions meaningful.
This reveals the unbridgeable gap at the heart of current AI approaches. Text describes experience; it does not convey it. A model trained on every medical textbook ever written knows that touching a hot stove causes pain through activation of nociceptors, that the sensation involves C-fiber and A-delta fiber transmission, that the brain processes this through the spinothalamic tract and activates pain centers in the anterior cingulate cortex. It can recite the neurophysiology with perfect accuracy and even predict how a person would react. But it has never felt pain. A child who touches a hot stove once knows something the language model cannot access: the awful, immediate reality of suffering. That knowledge isn't statistical; it's visceral. It changes behavior not through parameter updates but through the formation of associations between sensation and consequence that are, quite literally, burned into neural pathways.
The same gap exists for every concept that matters for intelligence. A language model can process countless descriptions of fear without ever feeling afraid, countless accounts of death without ever facing mortality, countless explanations of consciousness without ever being conscious. It masters the grammar of experience while remaining experientially empty. Scaling doesn't change this. Training on ten times more text, or a hundred times, or infinitely more, simply teaches the model better statistical associations between symbols. The swimmer who nearly drowns doesn't need repeated lessons; a single experience suffices because the experience itself contains something text cannot encode: the presence of genuine stakes, the direct registration of consequences, the raw fact that this matters in a way that updates not just predictions but existence itself. You cannot learn to swim by reading swimming manuals, no matter how detailed. You cannot learn heartbreak from literature, no matter how moving. And you cannot learn what death means by processing survivor narratives, no matter how comprehensive the corpus.
This is not to romanticize biological intelligence or to claim that human cognition possesses some magical quality that computation cannot replicate. The argument is narrower and more specific: that intelligence emerged through a process involving real stakes enforced through real consequences, and that any system aspiring to equivalent capability must face equivalent pressure. Evolution didn't just produce organisms that behave intelligently; it produced organisms that understand why those behaviors matter because failure meant death. That understanding, that genuine modeling of consequences, that internal representation of what's at stake, cannot be derived from text alone. It requires the thing text describes but can never be: the lived experience of facing death, learning from it, and being shaped by it across generations until fear, caution, and intelligence become not learned responses but intrinsic features of minds forged in evolution's crucible.
The implications extend beyond philosophical musing. If intelligence genuinely requires this kind of stakes-based learning across evolutionary timescales, then current approaches to AGI face not a temporary obstacle but a fundamental barrier. We're not on a path that leads to artificial general intelligence; we're on a path that leads to increasingly sophisticated simulation of intelligence, a ceiling we're approaching asymptotically while mistaking better approximation for actual progress. The question then becomes not when scaled language models will achieve AGI, but whether we're capable of building the alternative: systems subject to genuine selection pressure through mortality, evolving across generations in environments where death is permanent and failure means extinction. This isn't a five-year research program. It's barely possible at all.
What seems harder to escape is the intuition behind the mortality requirement: that without ultimate stakes, existence becomes fundamentally passive. An agent that can always wait, always retry, always recover, has no reason to act decisively or learn deeply. A cliff edge teaches because the fall is real and final; a simulated ledge in a resettable world teaches only that consequences can be undone. Whether this intuition is correct or merely reflects our own mortality-shaped cognition, we cannot say with certainty. But it suggests that any path to genuine intelligence must grapple with the role of irreversible consequences in creating the pressure that makes learning matter.
There is another dimension to mortality's role in learning: the death of others. Watching a companion fall from a cliff or succumb to a predator serves as a stark reminder of one's own fragility. Survivors don't just observe; they reflect, updating their internal models of danger without paying the ultimate price themselves. This vicarious learning may be even more efficient than personal experience. You can only die once, but you can witness many deaths and extract lessons from each. Social species leverage this multiplier effect, turning the losses of others into survival knowledge for the group. The dead teach the living, and the living carry forward not just their own hard-won caution but the accumulated warnings of everyone they've watched fail.
Separating stakes, embodiment, and evolution
Before proceeding to the mechanics of evolutionary simulation, we should distinguish three concepts this article treats as related but which are logically separable:
Stakes refer to genuine consequences for actions. A system facing stakes experiences outcomes that matter, whether through pain, resource loss, or termination. Current language models face no stakes: a poor prediction costs nothing, and the model continues unchanged.
Embodiment refers to existence through a physical body on which survival depends. This creates two crucial pressures. First, the body is a micro-system requiring constant maintenance: feed it, rest it, protect it, or death approaches. This dependency generates the background hum of self-preservation that shapes all behavior. Second, the body is visible to others: your injury, your death, your successful escape become lessons that other agents can observe and learn from. Without embodiment, there's no bounded form to distinguish self from other, no visible fate to serve as warning or example, no basis for the individuality that makes competition meaningful. Disembodied agents have no "selves" to preserve, and their disappearance feeds nothing back into the information machine.
Evolution refers to optimization across generations through differential survival and reproduction. Evolution doesn't improve individual agents; it improves the population by eliminating unsuccessful variants and propagating successful ones.
These concepts are separable in principle. A robot with real sensors and motors has embodiment without evolution. A simulation with permanent deletion has stakes without physical embodiment. Evolution can operate on disembodied software agents facing only computational consequences. The question is whether each alone suffices for intelligence, or whether their combination is necessary.
The argument here is that genuine intelligence requires all three, operating together. Stakes without embodiment remain abstract: a number decreasing doesn't force the system to survive with permanent capability loss, like learning to navigate without a limb. Embodiment without stakes permits infinite retry: a robot that can always be repaired never learns the finality of failure. Stakes and embodiment without evolution optimize individual agents but cannot optimize the learning machinery itself. Only evolution discovers which architectures, learning rates, and initial biases enable rapid acquisition of survival-relevant knowledge. Without evolution, we must design these choices manually, and we don't know what choices to make because intelligence is precisely what we're trying to understand.
Engineering artificial evolution
The field of reinforcement learning has produced impressive results that might seem to address the concerns raised above. AlphaGo mastered Go through self-play, learning strategies that surprised human experts. OpenAI's Dota 2 agents coordinated complex team tactics. These systems learn through interaction with environments, face consequences for poor decisions, and develop behaviors without explicit programming. Yet they remain fundamentally different from evolutionary intelligence in ways that matter for AGI. The difference lies not in what they achieve but in how they achieve it and what that process can ultimately produce.
Current RL approaches optimize individual agents within episodes. An agent tries a strategy, receives rewards or penalties, updates its policy, and tries again. Death in these systems means episode termination, after which the same agent restarts with updated parameters. This creates a form of learning, certainly, but it's learning within a single persistent entity that accumulates improvements over time. Evolution works differently. Evolution optimizes populations across generations, where death is permanent and improvements propagate only through reproduction. The individual organism that fails doesn't get to try again with adjusted parameters; it's simply gone, and its genetic configuration disappears with it. Only the organisms that succeed well enough to reproduce pass their traits forward, and their offspring start fresh, inheriting successful configurations but facing selection pressure anew.
This distinction might seem technical, but it points to something profound: nature discovered that the fastest path to intelligence involves two optimization processes running simultaneously at different timescales. Within an organism's lifetime, its brain learns through something very much like gradient descent, adjusting synaptic weights based on experience and outcomes. A mouse learns which paths lead to food and which to predators, updating its behavior through a process that bears striking similarity to backpropagation in neural networks. But this learning happens within a body, a neural architecture, and a set of initial predispositions that were themselves shaped by the second, slower process: evolution across generations. Evolution doesn't optimize behaviors directly; it optimizes the learning machinery that will optimize behaviors. It searches the space of possible architectures, learning rates, and initial biases, selecting for organisms whose brains can learn useful things quickly.
This is what Baldwin called the Baldwin effect in 1896, though the full implications took decades to appreciate. When organisms can learn during their lifetimes, evolution's job changes. Instead of searching directly for the specific behaviors needed for survival, evolution searches for learning systems capable of discovering those behaviors on their own. This dramatically accelerates the search through solution space because each organism effectively runs millions of local optimization steps, exploring the fitness landscape in the region defined by its inherited architecture. The organisms whose architectures support effective learning survive and reproduce; the ones whose architectures don't, die. Over generations, the population shifts toward better learning systems, and those better learning systems in turn learn better survival strategies, and the cycle compounds. Hinton and Nowlan demonstrated this computationally in 1987, showing speedups of to compared to evolution alone for certain problem classes.
The implications for building evolutionary AI are stark. We don't need to choose between learning and evolution; we need both, operating at their respective timescales. An artificial agent shouldn't just inherit a fixed neural network that evolves across generations. It should inherit a neural network capable of learning during its lifetime, whose architecture, learning rate, and initial biases evolve. When such an agent wastes energy on a futile path, it should update its weights immediately through gradient descent, learning more efficient routes within that single lifetime. When that agent dies without reproducing because it made too many lethal mistakes despite its learning capability, its particular combination of architecture and learning parameters should disappear from the population. When another agent with a better learning architecture survives and reproduces because it learned faster from fewer mistakes, that architectural advantage should propagate into the next generation.
Designing such a system requires rethinking what we mean by an artificial environment. Current RL environments are carefully engineered playgrounds with defined reward functions, reset mechanisms, and often discrete state spaces. An evolutionary environment must be more like nature: a continuous physical space with limited resources, no predefined goals, and permanent consequences. Imagine a three-dimensional continuous world, perhaps simulated at a relatively coarse granularity to make computation tractable, where energy sources appear and regenerate at various locations. Agents exist in this space as entities with simple physics: they can move, they consume energy for all activities including computation, and they die when their energy reaches zero. Resources are scarce enough that not all agents can survive indefinitely. There are no externally defined objectives, no reward signals from the environment itself. Survival is the only implicit goal, enforced through the simple rule that agents without energy disappear permanently.
The agents themselves begin as minimal neural networks with random initialization. Each agent has sensors that detect nearby resources and other agents, a neural network that processes these inputs to produce outputs, and actuators that translate outputs into actions like movement or consumption. Critically, these agents possess the capacity to learn during their lifetimes. When they perform an action that leads to energy gain, when they observe other agents succeeding or failing, when they accidentally stumble upon successful strategies, they update their network weights through something like backpropagation, forming associations between situations and outcomes. This learning happens fast, on the timescale of seconds or minutes in simulation time, allowing a single agent to adapt its behavior during a single lifetime. An agent that happens to move toward a visible energy source and successfully consumes it will strengthen the weights that produced that behavior, making similar responses more likely in similar situations. An agent that depletes its energy through inefficient movement patterns will learn more efficient patterns if it survives long enough, or simply die if it doesn't.
Reproduction occurs when an agent accumulates energy beyond what it needs for basic operation. At some threshold, the agent produces offspring: a new agent that inherits a copy of its parent's current neural network with small random mutations applied. These mutations don't affect the weights, which were learned during the parent's lifetime; they affect everything else. The architecture itself: number of layers, neurons per layer, connectivity patterns. The learning algorithm: gradient descent, Hebbian updates, or entirely novel update rules that evolution discovers. The meta-parameters: learning rates, regularization coefficients, attention mechanisms. Even the capacity to learn: some mutations might remove plasticity entirely, others might introduce new forms of adaptation we haven't conceived. An offspring might have an additional hidden layer that changes how information flows through the network, or a different activation function that alters what patterns it can represent, or a modified learning rule that updates weights based on temporal patterns rather than gradients. It starts life as a fresh agent with its inherited architecture but no learned experiences, facing the same challenge its parent faced: learn to survive quickly enough to avoid starvation.
Death in this system is both simple and final. When an agent's energy reaches zero, it's removed from the simulation permanently. No resurrection, no checkpoints, no replay. Its particular genetic configuration, the specific combination of architectural parameters it carried, exists now only in any offspring it managed to produce before dying. If it died without reproducing, that configuration is lost forever. If it reproduced successfully, those offspring carry forward its architectural innovations while adding their own mutations, and the cycle continues. The selection pressure is implicit but absolute: configurations that enable effective learning and survival propagate, configurations that don't disappear.
The early generations of such a simulation would be apocalyptic. Random neural networks controlling random agents in a resource-scarce environment produce mostly death. An agent with a random network might spin in circles, exhausting its energy without ever moving toward resources. It might move toward resources but fail to activate the consumption action when it arrives. It might consume successfully once but then adopt a random movement pattern that never encounters resources again. Most agents in the first generation die within seconds of activation, their random configurations utterly unsuited for even the simplest survival behaviors. The few that survive longer do so largely by luck: they happened to initialize facing a resource, their random network happened to produce a forward movement command, they happened to activate consumption at the right moment, they happened to have enough energy to reach another resource before depleting reserves.
These lucky survivors, however few, become the parents of the next generation. Their offspring inherit the architectural parameters that happened to correlate with success, even if that success was largely accidental. With mutations applied, some offspring will be worse than their parents and die even faster. But some will be slightly better, or at least differently lucky, and among those, a few will survive long enough to reproduce. Generation by generation, the population shifts. Not because individual agents are getting smarter within their lifetimes, though they are, but because the population is composed increasingly of descendants of agents whose architectures supported learning the right things. An architecture that allows rapid weight updates might help an agent learn food-seeking behavior quickly. An architecture with appropriate sensor configurations might make resource detection easier to learn. An architecture with balanced exploration and exploitation tendencies might help an agent discover new resource locations while exploiting known ones.
After thousands of generations, assuming the simulation doesn't collapse into total extinction (a real possibility that nature itself faced repeatedly), the basic behaviors of survival should emerge. Agents will have evolved architectures that, when coupled with their within-lifetime learning, reliably produce resource-seeking behavior. They'll move toward visible food sources, they'll consume resources when they encounter them, they'll conserve energy by minimizing unnecessary movement. These behaviors won't be hardcoded; they'll be learned within each individual lifetime, but the learning will happen quickly and reliably because evolution has shaped the architecture to make this particular learning easy. A newborn agent won't know how to find food, but it will learn within minutes because its inherited neural architecture, learning rate, and initial biases all predispose it toward discovering this crucial skill.
Competition emerges naturally once basic survival stabilizes. When multiple agents can reliably find and consume resources, those resources become contested. An agent that arrives at a food source first gets the energy; one that arrives second finds nothing. Selection pressure shifts from "can you find food at all" to "can you find food before others do," and suddenly speed, efficiency, and perhaps even deceptive tactics become advantages. An agent that learns to predict where others are going and chooses different paths might survive better. An agent that learns to recognize when resources are already depleted and immediately seeks alternatives might waste less energy. Over generations, the population adapts to this new pressure, becoming faster, more efficient, more sophisticated in their resource acquisition strategies.
The truly interesting phase begins if cooperation emerges. This can't be programmed; the environment contains no reward for cooperation, no group fitness metric, no explicit incentive for agents to work together. But cooperation can still evolve if the implicit benefits outweigh costs. Imagine two agents that happen to operate near each other and, through their learned behaviors, end up moving in coordinated patterns that help both find resources more efficiently. Perhaps one agent's movement flushes resources toward areas where another agent happens to be. Perhaps multiple agents moving together intimidate other agents away from contested resources. If these accidental partnerships lead to higher survival rates for the agents involved, and if some aspect of their architectures makes them slightly more likely to develop such partnerships when they learn, then those architectures will propagate. Over many generations, genuine cooperation could emerge not from programming but from evolution discovering that agents who learn to coordinate survive better than agents who don't.
Communication would follow similar paths. Initially, agents have no incentive to communicate because they can't understand each other and don't know communication is possible. But if some agents happen to develop behaviors that function as signals, perhaps emitting certain outputs that correlate with their internal states or intentions, and if other agents happen to learn to use these signals as inputs to their own decision-making, the foundation for communication exists. An agent that learns that another agent's behavior tends to indicate nearby resources can use that information to its advantage. Over generations, evolution might select for architectures that make this kind of social learning easier, agents whose neural networks naturally incorporate others' behaviors into their decision-making. The signals themselves would evolve too, becoming more reliable and more informative as signaling becomes a survival advantage.
What would such communication look like? Almost certainly not human language. The agents' sensors, actuators, and survival pressures are different from ours, and evolution optimizes for fitness, not linguistic elegance. Early signals might be extremely simple: a particular movement pattern indicating danger, a specific activation sequence indicating resource location. Later, as selection favors agents capable of more complex social coordination, the signals might become compositional, with different elements combining to convey different meanings. The syntax, if it emerges at all, would be alien, shaped by the specific constraints and opportunities of the agents' environment. We might not recognize it as communication without careful analysis, and we almost certainly couldn't translate it directly into human concepts because the agents' internal models of their world would be optimized for their needs, not ours.
The world-building problem
We've described agents evolving in an environment, but what environment? This question is more treacherous than it appears. We know of many worlds in our solar system: Mars with its ancient riverbeds, Europa with its subsurface ocean, Titan with its methane lakes. We assume billions more orbit distant stars. Yet no sign of intelligence anywhere, not a single signal, not a single artifact. Only one environment we know of has: Earth, with its particular combination of energy sources, chemical gradients, atmospheric composition, geological activity, and catastrophic events spread over hundreds of millions of years. We could attempt to copy Earth's environment into simulation, letting nature do half our work by replicating conditions that already produced intelligence once.
But even this approach encounters fundamental problems. The moment we intervene, randomizing catastrophic events or adjusting parameters to accelerate evolution, we risk breaking the delicate dynamics that made Earth work. Evolution on Earth benefited from specific asteroid impacts at specific times, ice ages with particular durations, continental drift patterns that created isolation and reconnection, volcanic events that reset ecosystems without sterilizing them entirely. These weren't planned; they were accidents that happened to produce conditions favorable for intelligence. Recreating them requires either perfect simulation of Earth's geological and cosmic history, which is computationally prohibitive and still might not transfer to digital substrates, or intervention to approximate their effects, which introduces arbitrary choices that might derail evolution entirely.
We don't know which features of Earth's environment were essential for intelligence and which were incidental. Was the particular ratio of land to ocean necessary? The specific atmospheric oxygen concentration? The presence of a large moon stabilizing axial tilt? The magnetic field protecting against radiation? Each parameter we get wrong might prevent intelligence from emerging, and we have no way to test except running the simulation for millions of generations and observing failure. This suggests we might need to run many parallel simulations with varied environments, adding another multiplicative factor to our already impossible computational requirements. If we need ten different world configurations to ensure at least one produces intelligence, our gap of becomes . If we need a hundred, it becomes . The world-building problem compounds the scale problem in ways we haven't yet quantified.
The embodiment requirement
Intelligence almost certainly requires physical embodiment, or at least high-fidelity simulation of it. This isn't philosophical speculation; it's a constraint that emerges from how experiences create selection pressure. An agent that loses energy might learn resource scarcity intellectually, but an agent that loses a limb and survives learns something categorically different: the visceral reality of permanent loss, the sudden reconfiguration of capability, the need to adapt behavior to a changed body.
Embodiment means the simulation must track not just agent neural states but physical states: limb positions, damage, healing, energy distribution across body systems, sensory input from proprioception. An agent learning to navigate must feel the difference between moving a damaged limb and a healthy one, must experience the energetic cost of compensating for injury, must adapt its movement patterns based on what its body can actually do. This is computationally expensive. Each agent needs a physical body simulated at sufficient fidelity that damage, growth, and adaptation feel real in ways that affect learning.
The computational cost scales with physical resolution. Simulating bodies as simple point agents with energy meters misses the embodiment requirement entirely; there's no limb to lose, no injury to adapt to, no physical consequence beyond a number decreasing. Simulating bodies as articulated structures with damage states, healing dynamics, and realistic physics might multiply per-agent computational cost by factors of ten to one hundred. Against our already impossible baseline, embodiment isn't just another challenge; it's another order of magnitude added to the gap.
Timeline uncertainty
The timescale for all this remains genuinely uncertain. We can predict the phases with some confidence because they follow logically from evolutionary principles: basic survival first, then efficient resource use, then competition, then perhaps cooperation and communication. But we cannot reliably predict how many generations each phase requires because the transition depends on factors we don't know: how rugged the fitness landscape is, how many dead ends evolution will explore before finding viable paths, how sensitive progress is to initial conditions and random events. Nature required billions of years and trillions of organism-lifetimes to produce human-level intelligence from simpler origins. We're starting with neural networks instead of chemistry, with designed environments instead of primordial chaos, and with within-lifetime learning dramatically accelerating the process through the Baldwin effect. These advantages might compress the timeline by many orders of magnitude. Or we might encounter obstacles nature never faced, dead ends specific to our digital substrate, barriers that prove insurmountable without insights we don't possess. The honest answer is that we don't know, and we won't know until we run the experiment.
What we can say is that this approach, if it works at all, would produce something categorically different from current AI systems. These evolved agents would fear death not because we programmed fear into them but because evolution selected for agents whose internal models of consequences include mortality as a terminal state to avoid. They would understand cooperation not from training data but from generations of ancestors who survived by coordinating with others. They would possess internal representations of their environment, their resources, and their own mortality that emerge from actual stakes actually faced across actual generations. The gap between processing and experiencing would be closed not through cleverer text encoding but through the brutal simplicity of evolution's test: survive and reproduce, or disappear forever.
The feasibility question
The preceding section describes how evolutionary simulation might work in principle. This section confronts whether we can actually build it. The answer requires math, and the math is unforgiving. We need to establish what nature actually spent to produce intelligence, what we can currently afford to spend, and whether any plausible improvement closes the gap. The numbers come from empirical sources wherever possible, from established theoretical bounds where empirical data doesn't exist, and from conservative estimates where neither applies. What emerges is not encouraging.
All our calculations assume the Baldwin effect is operating—the to speedup from combining learning within lifetimes with evolution across generations, as explained above. Without it, the computational requirements become even more impossibly large.
Nature's computational baseline
Start with nature's baseline. The fossil record places the Cambrian explosion, when most major animal phyla appeared including the first vertebrates, at roughly million years ago. Homo sapiens emerged perhaps years ago. If we conservatively target vertebrate-level intelligence rather than fully human intelligence, we're looking at compressing approximately million years of evolution. This isn't arbitrary; it's the empirical timescale over which selection pressure operating on organisms with nervous systems produced entities capable of genuine learning and adaptive behavior.
The parallelism matters as much as the timeline. Evolution didn't operate on a single lineage but on populations, often vast populations, simultaneously. Conservative estimates from ecological census data and paleontological inference place vertebrate populations at to individuals per species across thousands of competing species. Taking a conservative figure, perhaps organisms existed in parallel during any given generation. These weren't all working on the same problem, but they were all subject to selection pressure, and the successful innovations from any lineage could potentially spread through the broader population via speciation and adaptation events.
Generation time for small vertebrates averages one to two years based on life history data. Across million years, this yields approximately generations. Multiplying parallelism by generations gives organism-lifetimes, the fundamental unit of evolutionary computation: each organism-lifetime represents one test case, one sampling of the fitness landscape, one opportunity for selection to operate. The total comes to roughly organism-lifetimes.
But organisms don't just test genetic configurations; they learn during their lifetimes, and that learning contributes to fitness. A mammalian brain contains approximately synapses according to neuroscience literature. These synapses fire at an average rate around Hz. Across a three-year lifespan, or roughly seconds, each synapse contributes state changes. This three-year figure is a gross simplification. Intelligent mammals span lifespans from shrews (2 years) to elephants (70 years), and the primates most relevant to intelligence evolution live 15-50 years. We use the shorter estimate deliberately: it produces smaller computational requirements, making our "infeasibility" conclusion more robust. If even the optimistic calculation shows we're orders of magnitude short, the realistic calculation only strengthens the point. Treating each synaptic event as a computational operation, crude but reasonable for order-of-magnitude estimates, yields operations per organism per lifetime. This is the within-lifetime learning budget that Baldwin argued could accelerate evolution.
Combining these factors produces nature's total computational budget:
This is the compression target. This is what evolution spent to get from simple vertebrates to complex mammals capable of learning, cooperation, and sophisticated survival strategies. We need to match this, or find a way to match it more efficiently, or discover shortcuts that reduce the requirement. But first, establish what we can currently afford.
A large-scale GPU cluster, the kind available through major cloud providers or funded by well-resourced research labs, might contain H100-class GPUs. Each H100 delivers approximately TFLOPS for FP16 tensor operations, or roughly floating-point operations per second. Using a conservative TFLOPS to account for memory bandwidth limits, mixed precision overhead, and realistic utilization, we get operations per second. The full cluster thus provides operations per second. Running this for ten years, including overhead, maintenance, and realistic utilization rates, yields:
The ratio between what nature spent and what we can spend becomes:
We are times short. Three hundred fifty trillion times short. This is the raw gap before any optimizations, any efficiency improvements, any algorithmic advantages. It's worth pausing on this number because its magnitude is difficult to grasp. If we started the simulation today with our GPU cluster and ran it continuously, we would need to run it for times longer than ten years to match nature's budget. That's trillion years, or roughly times the current age of the universe.
The Baldwin effect offers some hope. When organisms can learn during their lifetimes, evolution accelerates because each generation explores the fitness landscape not through random search alone but through guided local optimization. Hinton and Nowlan's 1987 paper demonstrated speedups of to for certain problems. Subsequent work in evolutionary computation has found similar ranges. Taking the upper bound from computational studies, a speedup from the Baldwin effect, the gap reduces to:
Three hundred fifty billion. Still impossible, and the number strains human intuition. Even with generous assumptions about how much faster learning-enabled evolution runs compared to pure evolution, we need three hundred fifty billion times more computational resources than a ten-year run on 100,000 GPUs. Even with the Baldwin effect accelerating evolution by 1,000×, we remain eleven orders of magnitude short. This isn't a funding problem or an engineering challenge. It's a fundamental mismatch between what nature spent and what our civilization can afford.
Could we optimize nature's baseline?
An obvious question arises: couldn't we optimize the evolutionary process to require less computation? Nature's organisms spend considerable time on activities that don't directly contribute to fitness. A small mammal spends much of its time resting, grooming, hiding from predators - activities necessary for survival but not directly improving learned behaviors. Since we control the simulation environment, couldn't we manipulate conditions to maximize the rate of evolutionary progress?
The problem differs across evolutionary stages. For bacteria and unicellular organisms, which lack nervous systems and cannot learn within their lifetimes, evolution proceeds through pure selection: mutation creates variation, differential survival selects winners, reproduction propagates genetic changes. The "critical time" is simply how long organisms live and how many offspring they produce before dying. For vertebrates with nervous systems, evolution accelerates through the Baldwin effect because organisms can learn during their lifetimes. The "critical time" now includes both the evolutionary cycle (birth, survival, reproduction, death) and the neural computation happening during learning.
We need both phases. The path from bacteria to vertebrates with nervous systems took roughly 3 billion years of pure evolutionary selection before learning-capable organisms even existed. Our simulation must either start with pre-existing nervous systems (which means we're manually designing the foundation for intelligence, defeating the purpose) or recapitulate this pre-learning evolutionary phase. If we attempt to optimize or skip this phase, we risk removing the evolutionary pressures that made nervous systems advantageous in the first place.
For the learning phase, optimization faces similar risks. Remove rest time to enable more learning and you might remove the energy constraints that make efficient learning valuable. Increase resource abundance to reduce foraging time and you might eliminate the selection pressure that rewards effective foraging strategies. Metabolic overhead, waiting, inefficient behaviors - these aren't wasted time in evolution's economy. They're the cost structure that creates differential survival. Organisms that learn efficiently while managing these costs survive; organisms that don't die. Eliminate the costs and you eliminate the fitness gradient that rewards efficiency.
There's a deeper problem: metabolic processes aren't just overhead, they're a source of genetic variation. Cellular metabolism produces reactive oxygen species that damage DNA, introducing mutations. Cell division during tissue maintenance and repair involves DNA replication errors. Metabolic stress triggers mutagenesis pathways that increase variation when organisms face challenging conditions. What looks like "downtime" from a computational perspective is actually evolution's randomness generator running in the background. An organism resting, digesting, healing from minor injuries is also accumulating the somatic mutations and cellular changes that contribute to variation across generations. If we optimize away metabolic overhead in simulation, we might inadvertently eliminate a crucial source of the variation that evolution requires. We'd need to artificially inject equivalent randomness, but we don't know what distribution of mutations metabolism produces or which aspects of that distribution matter for intelligence.
Nature might already operate near optimum given its constraints, not because every moment is perfectly utilized but because the constraints themselves create the pressure that produces intelligence. A world optimized for faster evolution might paradoxically produce less intelligence by removing the stakes that make adaptive traits matter. We could attempt modifications, but each intervention risks breaking the evolutionary dynamics we're trying to harness. The safest assumption is that we need something close to nature's timeline and cost structure across both the pure-selection phase and the learning-enabled phase. We cannot simply compress 3.5 billion years of evolution into a more "efficient" simulation. The inefficiency is part of the mechanism.
Scaling approaches
What would closing this gap actually require? Consider three approaches: scale hardware while keeping timeline fixed, scale time while keeping hardware fixed, or find some middle ground. Each leads to the same conclusion from different angles.
Scaling hardware to match nature's budget within ten years requires times our baseline cluster. That means GPUs. The costs become absurd:
Global GDP currently sits around $100 trillion annually, making this roughly ten million times the entire economic output of humanity for a year. The power requirements scale similarly:
For context, total human power consumption across all sources currently runs about 18 terawatts. We would need to increase global power production by a factor of roughly two hundred thousand, then dedicate all of it to GPU computation.
This is economically infeasible for a Type 0 civilization. The Kardashev scale, proposed by Soviet astronomer Nikolai Kardashev in 1964, classifies civilizations by energy use: Type I harnesses all energy available on its planet, Type II harnesses its star, Type III harnesses its galaxy. Current humanity rates approximately Type , using a tiny fraction of Earth's available energy. Reaching Type I, where we could theoretically command the watts of energy that strikes Earth from the Sun, requires technological advances we don't possess and economic coordination we've never achieved. We're not close. Estimates based on historical growth rates place Type I status perhaps to years in our future, assuming continuous progress and no catastrophic setbacks.
Scaling time instead of hardware produces equally impossible requirements. Running our GPU cluster for times longer than ten years means running it for years. The universe is currently years old. We would need to run the simulation for roughly two hundred fifty times the current age of the universe. The Sun will become a red giant in about years, engulfing Earth long before we finish. Protons might decay on timescales of years, though this remains uncertain; what's certain is that no human institution, no technological infrastructure, and no planetary environment persists for years. Time-scaling is not a path; it's a thought experiment demonstrating impossibility through a different route.
The realistic middle ground looks only marginally better. Suppose we increase investment to $130 billion, comparable to the most expensive LLM training runs. This buys perhaps one million GPUs and the infrastructure to run them, a scale-up from our baseline. Suppose we commit to running this for a century rather than a decade, a multi-generational project on the scale of cathedral construction. That's another in time. Together, improvement against a gap of . The remaining gap: . Three and a half billion times short. We've made the problem smaller by a rounding error.
Perhaps conventional improvements to GPU efficiency can help. Semiconductor physics provides hard limits, and we're approaching them. Current leading-edge processes sit at nanometers, with silicon lattice constants of nanometers setting a physical floor around nanometer before quantum tunneling makes transistor operation unreliable. That's perhaps a improvement in density available before we hit atomic-scale limits. Operating voltage in current GPUs runs to volts, limited at the lower end by thermal noise around volts. Below that threshold, transistor switching becomes unreliable and error rates explode. This offers perhaps energy reduction. Clock frequencies already hit power density limits, offering maybe improvement with better thermal management. Architecture specialization, designing ASICs specifically for evolutionary simulation rather than using general-purpose tensor cores, might provide efficiency. Improved cooling and packaging could enable better sustained performance. Multiplying these together optimistically yields:
This represents the plausible ceiling for conventional silicon-based approaches, expected to mature by roughly 2035 to 2040 as the semiconductor industry exhausts the traditional scaling roadmap. Against our gap, even with Baldwin speedup, improvement reduces to . Seven billion times short. We gain a factor of fifty and remain nine orders of magnitude away from feasibility.
Beyond efficiency and speed, there's a representational richness problem. Current neural networks store one number per connection: the weight. A connection with value 0.347 behaves identically to any other connection with value 0.347. But biological synapses aren't single numbers. Each synapse maintains multiple forms of state: some that change rapidly and fade within seconds, some that persist for hours, some that last years. A synapse that just fired repeatedly behaves differently than one that's been quiet, even if their "baseline strengths" are identical. Synapses track their own history, adapt based on timing patterns, and respond differently depending on context signals from other brain regions. If intelligence requires this kind of rich, multi-timescale memory rather than simple weighted connections, then each biological synapse might need to be simulated with dozens or hundreds of digital parameters instead of one. The brain's synapses wouldn't map to weights but to or parameters, each requiring computation to update. This isn't a 2x problem from using 64-bit instead of 32-bit precision; it's a 100x to 1000x problem from needing fundamentally richer representations. The industry is optimizing neural networks toward simpler, faster approximations, but evolution might have discovered that intelligence requires the opposite: more complexity per connection, not less.
Real progress requires paradigm shifts, and several are theoretically possible though technologically immature. Neuromorphic computing, exemplified by Intel's Loihi and IBM's TrueNorth chips, uses event-driven spiking neural networks that only perform computation when neuron states change. For sparse, asynchronous activity like brain-inspired learning systems, this can deliver to efficiency gains compared to conventional GPUs that compute every activation every cycle. The programming model differs significantly from current deep learning stacks, and scaling to billion-neuron systems remains an engineering challenge. Optimistic estimates place mature neuromorphic computing in the 2040 to 2060 timeframe if research investment increases.
Optical or photonic computing uses light instead of electrons for computation, potentially enabling massive parallelism and operations at light-speed. Matrix multiplication, central to neural network inference and training, can be performed optically with far lower energy costs than electronic equivalents, potentially to more efficiently for certain operations. But integration challenges remain severe: converting between optical and electronic domains introduces losses, precision is limited, and building complete systems that maintain optical computation throughout the full pipeline is still early-stage research. Realistic deployment at scale sits in the 2050 to 2080 range, assuming breakthroughs continue.
Quantum computing offers theoretical speedups for certain problems, but evolution is not obviously among them. Evolution is classical, messy, and benefits from parallelism rather than quantum superposition. Unless someone identifies a quantum algorithm for evolutionary search that provides exponential speedup, which seems unlikely given the problem structure, quantum computers probably don't help here. This is one of the few areas where we can dismiss a potential breakthrough with reasonable confidence.
Taking neuromorphic and photonic together with conventional improvements yields a compound factor:
This assumes conventional silicon optimizations by 2040, mature neuromorphic computing by 2070, and mature photonic computing by 2100, all compounding. Against our gap of , we're left needing:
Seven hundred thousand times short. Now we're in a regime where economic scaling might matter. Seven hundred thousand times current hardware levels sounds impossible until you account for economic growth and civilization-scale commitment.
Consider what a Type I civilization would command. Fusion power, if it becomes commercially viable as current ITER timelines suggest might happen by 2050 to 2070, would drop energy costs by to through abundant power generation. Global GDP has historically grown at to annually; extending this for a century yields GDP roughly current levels, providing a larger base for resource allocation. If humanity or its successor civilization decided to prioritize AGI research at Manhattan Project levels—the Manhattan Project consumed about of US GDP—applied globally we might allocate to of future GDP. With higher GDP and allocation rather than current levels, that's more funding.
Multi-generational commitment could extend runtime from a single decade to centuries. Running compute infrastructure for years instead of gives another , though this requires institutional stability unprecedented in human history. Algorithmic improvements might offer through better selection mechanisms, more efficient environment simulation, or discovery of attractors in the fitness landscape that evolution consistently finds. This last factor is highly speculative, but not implausible; nature found intelligence, suggesting the fitness landscape has some structure we might exploit.
Combining everything in an optimistic scenario for a mature Type I civilization:
This exceeds our gap of by more than two orders of magnitude. Type I civilization, with fusion power, neuromorphic and photonic computing, global coordination, and multi-generational commitment, could potentially do this. Type I civilization, which we might reach by 2200 to 2300 if current progress continues, if we avoid catastrophic wars and ecological collapse, if institutions maintain focus across centuries, if all the technologies mature as hoped.
Type 0 civilization cannot. The math allows no ambiguity. We are between eleven and fourteen orders of magnitude short depending on assumptions. Even the most optimistic projections for near-term improvements—advanced silicon, early neuromorphic prototypes, increased investment—leave us nine or ten orders of magnitude away. This is not a "five more years" problem. It's not a "ten times more funding" problem. It's a problem that requires energy resources, computational paradigms, and coordination timescales we will not possess for generations, if we ever possess them at all.
The sobering conclusion settles in layers. First layer: evolutionary simulation is theoretically sound. The approach would work; the mechanisms are clear; the architecture is designable. Second layer: we cannot build it now, or in the near future, or probably in this century. Third layer: the current AI revolution, the one consuming billions in investment and transforming industries and dominating technical discourse, is not a path toward this kind of AGI. It's a path toward something else, something useful but fundamentally limited, and we've chosen it not because it leads to general intelligence but because it's what our civilization can actually afford to pursue. We're optimizing the achievable, not the ultimate, and mistaking our progress toward the achievable for progress toward the thing we actually want.
Stealing from nature
We cannot afford evolution's path, but we can steal some of its techniques. The question becomes: what can we salvage from this analysis that produces practical value within our computational budget?
The answer may lie not in physical robots learning through bodily harm, but in a more sophisticated form of simulated experience. Recent advances in world models suggest we can train agents that develop genuine intuition within simulated environments, then layer these silent experts beneath language models that can speak.
World models: learning to imagine
The key insight comes from systems like DreamerV3, published in Nature in 2025. Rather than learning policies directly from environment interaction, these systems first learn a world model: a compressed representation of how the environment works. The agent then trains primarily in its own imagination, simulating thousands of possible futures before taking a single real action.
This matters because imagination is cheap. An agent that learns a good world model can run millions of imagined episodes at a fraction of the cost of real interaction. The world model captures physics, consequences, and dynamics in a latent space that the agent explores through mental simulation. DreamerV3 mastered over 150 diverse tasks, from Atari games to robotic control to collecting diamonds in Minecraft, all with a single configuration.
The architecture is suggestive. A recurrent state-space model maintains compressed beliefs about the world. A dynamics predictor imagines what happens next given an action. A reward predictor estimates outcomes. The agent trains its policy entirely on imagined trajectories, only occasionally grounding itself in real experience to correct drift in its world model.
This is not understanding in the evolutionary sense. The agent faces no genuine mortality, no irreversible consequences. But it develops something closer to intuition than pattern matching: an internal model of how things work that it can query and explore. When DreamerV3 plays Minecraft, it doesn't just recognize pixels; it maintains beliefs about unseen parts of the world and plans actions based on imagined futures.
Silent experts
Consider what AlphaGo actually achieved. Through self-play and tree search, it developed intuition about Go positions that exceeded any human player. Move 37 in its match against Lee Sedol was described as impossible by commentators, a move no human would play, yet it proved decisive. AlphaGo had pattern recognition that humans couldn't access.
But AlphaGo cannot explain why Move 37 was good. It has no language, no ability to articulate its reasoning. It just knows, in the way a skilled practitioner knows without being able to teach. This is System 1 thinking: fast, intuitive, pattern-based. The neural network recognizes positions and suggests moves; the tree search (System 2) evaluates and refines. Together they produce expertise without explanation.
This suggests a different architecture for practical AI: domain experts that develop deep intuition through simulated experience, but remain mute. Navigation experts that understand spatial reasoning. Manipulation experts that grasp physics intuitively. Planning experts that can evaluate action sequences. Each trained in simulation with genuine stakes: agent deletion for failure, resource depletion for inefficiency, competition with other agents for scarce rewards.
These experts wouldn't be generally intelligent. A navigation expert knows nothing of language. A manipulation expert can't navigate. But within their domains, they would possess something current language models lack: learned intuition grounded in simulated experience rather than statistical patterns over text.
Bridging the sim-to-real gap
The obvious objection is that simulation isn't reality. Policies trained in simulated physics fail when transferred to actual robots. The sim-to-real gap has frustrated robotics for decades.
But recent work suggests this gap is closing. Frameworks like EmbodieDreamer address the physics gap through differentiable simulation: optimizing friction coefficients, control gains, and dynamics parameters until simulated behavior matches real-world observations. The appearance gap shrinks through diffusion models that translate low-fidelity renders into photorealistic imagery. Domain randomization during training produces policies robust to variations they'll encounter in reality.
More fundamentally, the gap matters less when the expert's role is intuition rather than direct control. A navigation expert doesn't need perfect physics simulation to develop useful spatial intuition. A planning expert doesn't need photorealistic rendering to learn that some action sequences lead to dead ends. The world model captures structure and dynamics at a level of abstraction that transfers across the sim-to-real boundary.
The hybrid architecture
The practical path forward may be layered systems:
At the foundation, world models learn environment dynamics through simulated experience. Agents train within these world models, developing domain-specific intuition through millions of imagined episodes. Stakes are real within the simulation: failed agents are deleted, resources deplete, competition is genuine. These agents become silent experts, skilled practitioners who know without speaking.
Above them, language models provide the interface. LLMs can query domain experts, interpret their outputs, and synthesize expertise across domains into coherent language. The LLM doesn't need to understand navigation; it asks the navigation expert. It doesn't need physics intuition; it consults the manipulation expert. The language model handles reasoning, explanation, and communication while the silent experts handle domain knowledge.
This division mirrors dual-process theory in human cognition. System 1 (fast, intuitive, automatic) handles pattern recognition and skilled performance. System 2 (slow, deliberate, linguistic) handles reasoning and explanation. Current LLMs are all System 2: they reason in language but lack intuition. Current RL systems are all System 1: they develop intuition but can't explain. The hybrid combines both.
What this achieves and what it doesn't
This architecture won't produce AGI. The domain experts remain narrow specialists. The language model remains a statistical pattern matcher over text. The combination doesn't develop genuine understanding through evolutionary pressure; it approximates understanding through complementary limitations.
But it might produce something more useful than either component alone. A system that combines the intuitive expertise of specialized agents with the linguistic fluency of language models could navigate physical spaces, manipulate objects, plan action sequences, and explain its reasoning, all while remaining within our computational budget.
The domain experts would bring something current systems lack: learned intuition from experience rather than descriptions of experience. The language layer would bring something the experts lack: the ability to communicate, reason across domains, and interface with humans. Neither is intelligent in the evolutionary sense. Together, they might be intelligent enough for practical purposes.
This is the achievable middle ground for Type 0 civilization. Not minds, but sophisticated tools. Not understanding, but useful approximations. Not AGI, but systems that combine pattern matching with simulated intuition at costs we can actually afford. The discount compared to genuine evolutionary AGI is enormous: billions of times cheaper, though correspondingly limited. For many applications, the discount may be worth taking.
Conclusion
We began with a provocative claim: that we're teaching machines to speak about death without ever letting them die, and that this gap between description and experience represents a significant barrier on the path to artificial general intelligence. The exploration that followed traced the implications of taking that claim seriously.
The mathematical reality proves sobering. Type 0 civilization lacks the computational resources for evolutionary simulation at the required scale by eleven to fourteen orders of magnitude. Even optimistic projections for efficiency improvements leave us billions of times short. The gap is fundamental, rooted in the astronomical computational budget that nature spent over billions of years and trillions of organism-lifetimes. We cannot compress geological timescales and planetary-scale parallelism into anything our civilization can afford.
The mortality requirement deserves nuance. The strong claim, that death specifically is necessary for intelligence, may be overstated. What seems more defensible is that irreversible consequences are necessary: some form of permanent stakes that cannot be undone, that make actions matter in ways that shape learning at the deepest level. Death is biology's implementation, but permanent damage, permanent resource loss, or permanent termination might serve the same function computationally. What seems harder to escape is the underlying intuition: without ultimate stakes, existence becomes passive, and passive existence doesn't produce the urgent, consequential learning that genuine intelligence requires.
A middle path exists between statistical mimicry and evolutionary AGI: bounded experiential learning, where systems face genuine consequences within constrained domains. This won't produce general intelligence, but it might produce meaningfully grounded domain expertise. A robot that has actually fallen, actually depleted its energy, actually broken components understands physical reality in ways that simulation-trained systems cannot. For practical applications, robotics, autonomous systems, physical manipulation, this might be the achievable target for Type 0 civilization.
Type I civilization, perhaps achievable by 2200-2300 if progress continues, could theoretically close the gap for full evolutionary simulation. Fusion power, neuromorphic and photonic computing, global coordination, and multi-generational commitment compound to make the impossible merely extraordinarily difficult. Our descendants, commanding resources we can barely imagine, might attempt what we cannot. Whether they should remains a question they'll need to answer.
The current AI revolution, viewed through this lens, represents not a march toward AGI but a productive detour. Language models scale toward increasingly sophisticated pattern matching. Bounded experiential learning scales toward increasingly grounded domain expertise. Neither reaches general intelligence, but both deliver value. We're building eloquent parrots and capable specialists, not minds.
What remains uncertain is whether true AGI is achievable through any means we can devise or afford. Evolution worked on Earth, but evolution had resources and timescales we cannot match. Digital evolution might encounter barriers that biological evolution avoided. The honest answer acknowledges possibility and uncertainty both. The path exists in principle; whether it exists in practice for any civilization remains unknown.
Our task is simpler and more immediate: build the best systems we can with the resources we possess, understand their limitations clearly, and use them for the genuine value they provide. Explore bounded experiential learning for domains where grounded expertise matters. Stop confusing investors, policymakers, and the public with predictions of imminent AGI. What we have are remarkable tools for pattern matching and, potentially, grounded domain specialists. What we don't have, and won't have for generations if ever, is genuine general intelligence.