The Big Blob of Compute Hypothesis

Compute Shapes Intelligence

The author presents the Big Blob of Compute hypothesis as a tentative, experience-informed intuition underlying their views on both AGI timelines and safety, rather than a precise or confidently established theory.
The hypothesis holds that intelligent behavior emerges primarily from large, minimally structured computational capacity shaped by training and interaction with a rich environment.
Training signals, environmental design, and the amount of experience are the most effective levers for determining an agent’s performance and behavior; sufficient compute and storage enable it to learn the necessary cognitive skills.
The author favors compute-driven explanations of AI progress but argues that the compute-versus-algorithms debate overlooks environmental design and blurs whether abundant compute is sufficient or necessary for AGI.
Useful algorithmic choices generally exploit simple symmetries, improve regularization or conditioning, or smooth computational structure; supposedly fundamental algorithmic distinctions often merely reorganize the same underlying computations.
This perspective leads the author to question safety frameworks that operate at the wrong level of abstraction, although the specific safety implications are deferred to later sections.

It says that creating any given intelligent behavior is mostly about providing a large, minimally structured mass of computational capacity, and then giving it shape and form via interactions with a rich environment and a training process that drives it towards behavior appropriate for the task at hand.

Compute, Experience, and Generalization

The BBOC hypothesis argues that relatively unstructured computation often outperforms human-designed task decompositions; architectural choices can obstruct learning more easily than they can improve it.
The author treats an agent’s environment and training process as the main determinants of its behavior, shaping their views on AI timelines and safety and motivating skepticism toward MIRI’s HRAD agenda and framework-style safety plans.
Learning requires sufficient compute that flows freely between observations and actions, along with enough storage for both persistent task knowledge and temporary information about individual task instances.
Agents need substantial experience interacting with their task environment. Static data is one form of experience, and internal simulation can partly substitute computation for external experience.
Training should make generalizable solutions simpler than task-specific shortcuts. Shared underlying principles can support success on very different test tasks, while gradually increasing training difficulty may also be necessary.

More broadly, algorithms matter much more in a negative sense than a positive sense -- it’s possible to come up with horrible architectures that totally block the flow of compute, but it’s really hard to beat the unstructured blob by all that much, and it’s also really hard (perhaps impossible) to use algorithmic changes to get the agent to do anything other than what’s implied by its environment and training process.

Designing Learnable AI Behavior

Simple normalization and conditioning methods, such as Adam, BatchNormalization, and ResNets, can stabilize numerical computation and outperform more sophisticated algorithmic ideas.
Exploiting symmetries, such as spatial invariance in convolutional networks and temporal invariance in RNNs, reduces parameter requirements and accelerates learning.
Computational architecture should avoid narrow information bottlenecks and premature compression; as tasks become more general, fixed symmetries may become less useful, potentially giving way to meta-learned alternatives.
Training processes determine what behavior a system ultimately learns. Misaligned targets can teach the wrong task, such as imitating conversational responses rather than achieving a conversational goal, or expecting transfer without training for it.
A training target can be a multipart process rather than a single objective. The BBOC framework claims that getting principles 1–6 right should enable learning the behavior specified by principle 7, provided it is computationally tractable.

You will learn whatever the training process asymptotically incentivizes; if you have the wrong training process, you’ll learn the wrong task.

Intelligence as Emergent Structure

The author’s “snowflake model” portrays intelligence as an emergent product of suitable training targets, compute, parameters, and experience—not something assembled piece by piece through hand engineering.
Hand-engineered improvements on narrow tasks can produce impressive results while sacrificing robustness and generalization, creating a misleading impression of algorithmic progress.
The author argues that narrow benchmarks obscure the relationship between compute and results, whereas large projects and broader tasks make the BBOC perspective more apparent.
Traditional algorithms such as sorting can generalize perfectly to new instances of their specific task, yet offer no ability to solve tasks outside that domain.
Moving beyond specialized algorithms requires heuristic searches over programs and, the author argues, inevitably introduces learning, parameters, and substantial compute for sufficiently general tasks.

Furthermore, this is your only way to make snowflakes and your only leverage over their shape; trying to piece together a single one from little bits of ice is basically hopeless.

What Drives AI Performance

The author argues that BBOC has far-reaching implications for intelligence and contradicts many common claims about deep learning.
Convolutional neural networks succeeded in vision by combining sufficient compute and parameters, less rigid computation, and training objectives focused on identifying the final object rather than isolated subtasks.
Across hundreds of training experiments, the author finds that simple architectures work well when fundamental training requirements are met; architectural ingenuity cannot compensate for inadequate compute, parameters, or data.
A Google experiment replacing neural-network layers with another machine-learning technique produced working but slightly weaker models, which effectively learned to reproduce standard neural-network computations internally.
These results suggest that neural networks are effective but not uniquely magical: useful computations may emerge within different model types rather than depending on a particular architectural label.

it's more that certain computations really want to occur and will shape themselves around whatever type of model you give them.

Computation Over Algorithmic Structure

The distinction between model-based and model-free reinforcement learning may be less important than how computation is organized: model-free policies can learn internal models and potentially plan through repeated internal processing.
Model-based systems may perform poorly because separating prediction and action into disconnected components imposes an artificial constraint on computation.
Hierarchical reinforcement learning has struggled to outperform ordinary methods, with explicit goal hierarchies often collapsing into behavior resembling a single deeper neural network.
Large ordinary reinforcement-learning policies are showing surprising success over long horizons, including tasks with rewards only every 10,000 timesteps; useful hierarchies may emerge implicitly rather than require explicit design.
Properly tuned simple recurrent networks can match LSTMs, and RNNs, LSTMs, and GRUs appear similarly capable at equal parameter and compute budgets; LSTMs mainly offer robustness across a wider range of hyperparameters.

It’s possible we’ll eventually make hierarchical RL work, but for now it seems to be yet another example of compute having its own idea about what it wants to do and routing around the structure imposed on it by a supposedly important algorithm.

Generalization Beyond Algorithm Choice

The author argues that neural networks generalize primarily through diverse training data and environments, rather than through a yet-undiscovered superior algorithm.
Training speech models on several accents can improve performance on unseen accents: broader exposure encourages learning shared patterns instead of memorizing individual peculiarities.
Neural networks already represent uncertainty, and both neural and idealized Bayesian models face exponential parameter costs when representing full joint distributions.
Bayesian models do not automatically make beliefs interpretable or well calibrated; the difficult task of dividing the world into meaningful propositions remains necessary for either approach.
Although Bayesian methods offer idealized advantages against overfitting, practical techniques such as dropout can approximate Bayesian inference, and explicitly Bayesian neural networks have not shown clear superiority in generalization or calibration.

To summarize: it’s not algorithms that lead to generalization, so much as the training setup and environment.

Learning the Right Objectives

The BBOC perspective explains adversarial vulnerability through training objectives and experience: systems acquire what optimization rewards, not every property humans expect them to have.
The author argues that training directly on adversarial examples is the strongest current defense, while generative models trained to distinguish natural images offer a promising longer-term approach.
Replacing backpropagation with a new update rule is unlikely to revolutionize learning; choosing the right optimization target matters more than modest algorithmic improvements.
Transfer learning improves when training explicitly optimizes performance after rapid adaptation, rather than merely training on many tasks and then fine-tuning.
Handcrafted reinforcement-learning methods for exploration, motivation, and safety may give way to meta-learning across many agents’ learning processes, though this direction remains uncertain.
Symbolic reasoning is not exclusive to non-ML systems: neural networks can guide theorem proving and search over programs, and the author expects appropriately structured networks to learn simple programs from diverse environments.

BBOC says you get what you optimize for; what you don’t get is a human’s idea of what properties the system should have.

Scale Versus Handcrafted Intelligence

Neural networks that learn to search over programs could outperform fixed symbolic methods even on symbolic tasks, using more computation in line with the author's BBOC thesis.
Human evolution illustrates how sufficient computation, minimally structured memory, diverse challenges, and competition between agents can produce extraordinary intellectual capabilities.
BBOC does not guarantee that scaling today's algorithms will yield AGI; the author expects scale to remain central alongside relatively simple architectural changes or training innovations.
Apparently promising research directions can turn out to merely rearrange computation or prescribe solutions too rigidly, motivating skepticism toward handcrafted approaches and purported alternatives to deep learning.
Narrower, lower-level projects can still be valuable stepping stones toward more general learning systems, helping researchers understand how to design higher-level algorithms.

Model-based, hierarchical, and exploration are still controversial -- maybe we’ll still get something out of them -- but they are starting to look increasingly suspicious, increasingly like the edge detectors of 2011.