Capability Frontiers › Emerging Capabilities

One of the most striking findings in modern AI research is that some capabilities appear not gradually but abruptly as models scale. These emergent capabilities exist as though a threshold must be crossed before a behavior becomes reliable. Below a certain scale, the model produces noise or random guesses. Above it, performance jumps to useful or even expert-level quality.

The term "emergence" here carries a specific technical meaning. A capability is emergent when it cannot be predicted by extrapolating from performance at smaller scales, and when the behavior appears qualitatively different rather than just quantitatively better. The claim is that an apparently new behavior appears, rather than merely improving faster.

This definition requires some care. Some researchers have argued that apparent emergence can be an artifact of nonlinear evaluation metrics rather than a true discontinuity in underlying capability. If you measure performance with a threshold metric (does the model get the answer exactly right or not?), small continuous improvements in the underlying latent ability can produce a sudden jump in measured accuracy once the latent ability crosses the correctness threshold. This is an important methodological concern, and it motivates using smooth metrics alongside binary ones when evaluating capability curves. Nevertheless, certain behaviors do appear reliably only above certain scales, and whether the emergence is "real" at the latent level or a measurement artifact, the practical implication is the same: these behaviors are not available at small scale and become available at large scale.

Perhaps the most discussed emergent capability is in-context learning: the ability to adapt to new tasks given only a few examples in the prompt, without any gradient updates to the model's weights. You provide a handful of input-output pairs, and the model generalizes to new inputs in the same format.

What makes this striking is that the model is not being trained. Its weights are frozen. Yet somehow, reading a few examples activates the right behavior. The model appears to recognize the task structure from the examples and apply it to new inputs. This is a fundamentally different kind of learning from gradient-based fine-tuning: the "update" happens entirely within the forward pass.

Mechanistic interpretability research has offered one hypothesis for how this works: large models learn an implicit learning algorithm during pretraining. When given examples, the model essentially runs gradient descent in the forward pass, adjusting its internal representations to fit the demonstrated pattern without updating any weights. This framing is speculative but has been supported by some theoretical work showing that transformers have the computational structure to implement gradient-based learning. The key observation is that attention heads can implement the update rule for a linear model, with keys and values playing the roles of stored data points and queries playing the role of new inputs.

A simpler hypothesis is that in-context learning is a form of retrieval: the model retrieves relevant knowledge and patterns from its pretraining distribution, conditioned on the examples provided. Under this view, the examples are not teaching the model anything new but rather narrowing the space of behaviors it considers appropriate. Both hypotheses may be partially right, and the mechanism may differ depending on the task and model size.

The practical implications are significant regardless of mechanism. In-context learning allows a single model to serve many tasks without fine-tuning, reducing the engineering overhead of deployment. It also raises questions about what "knowing" a task means for a language model: if you can specify a task entirely through examples, the boundary between "tasks the model knows" and "tasks the model doesn't know" becomes blurry.

Performance on in-context learning tasks scales with both the number of examples and the model size. More examples help more for larger models, suggesting that smaller models lack the capacity to extract and use pattern information from long contexts as effectively. The quality of the examples also matters substantially: ambiguous, inconsistently formatted, or incorrectly labeled examples degrade performance more than having fewer high-quality examples.

A second emergent capability involves reasoning chains. When prompted to show its work, a sufficiently large model can break a problem into steps, work through each step, and arrive at a more reliable answer than if asked to respond immediately.

This capability, called chain-of-thought prompting, was discovered empirically and has since been extensively studied. The pattern is consistent: below a certain model size (roughly 100 billion parameters in some studies), chain-of-thought prompting does not help or can even hurt performance. Above that threshold, it substantially improves accuracy on multi-step reasoning tasks. The reason smaller models fail to benefit is not entirely clear, but one hypothesis is that they lack the parametric knowledge required to successfully execute the intermediate steps, so showing the steps only exposes errors rather than reducing them.

The mechanism behind this improvement involves several factors. By externalizing intermediate steps, the model can check its work at each stage and course-correct rather than letting early errors compound silently. The chain of reasoning also allows the model to use the context window as a kind of scratchpad, storing partial results that would otherwise need to be compressed into a single hidden state. This is especially valuable when problems require tracking multiple interacting quantities or when the final answer depends on applying transformations in a specific order.

There is a deeper point here about what chain-of-thought does cognitively. Human experts who work through problems on paper are not just showing their work for an audience; the external representation is a cognitive prosthesis. By offloading intermediate results to paper, they free up working memory for higher-level reasoning. The context window appears to serve an analogous function for language models: externalizing state that would otherwise need to fit in the finite-dimensional hidden state.

Extensions of this idea include several variations that address different failure modes. Self-consistency samples multiple independent reasoning chains and takes a majority vote on the final answer, reducing the impact of any single reasoning path going astray. Tree-of-thought explores multiple candidate reasoning paths simultaneously, allowing the model to evaluate and prune branches that seem unpromising before they have been fully developed. Least-to-most prompting decomposes a hard problem into a sequence of progressively easier subproblems, with each subproblem's answer becoming context for the next, preventing the model from having to bridge too large a reasoning gap in a single step.

Each of these extensions builds on the same core insight: externalizing intermediate computation improves reliability, and structuring how that computation is externalized further improves it.

Early language models were trained to predict the next token, not to follow instructions. They would complete a prompt but had no notion of what a user was asking for. A model asked "What is the capital of France?" was as likely to respond with "What is the capital of Germany?" (completing a pattern of geography quiz questions) as with "Paris." A significant capability shift came when models were trained on human feedback to produce responses that matched human intent, a process called reinforcement learning from human feedback (RLHF).

The resulting models display dramatically improved instruction following. They can interpret ambiguous requests, apply implicit constraints, maintain conversation context across turns, and adjust their behavior based on user feedback within a conversation. This shift transformed language models from completion engines into assistants.

What makes instruction following interesting from a capability standpoint is how general it is. A model that learns to follow instructions on thousands of task types during fine-tuning appears to develop a general notion of intent. Rather than memorizing what to do for each task type, the model learns to model what the user wants. This general intent-following capability transfers to novel task types that were not explicitly in the fine-tuning data.

The development of instruction following as a capability is tightly connected to the development of alignment as a field. When a model follows instructions reliably, it is also a model that could in principle follow harmful instructions just as reliably. Understanding where the limits of instruction following are, and how to set those limits appropriately, is one of the central challenges in deploying these systems responsibly. We will return to this in the chapters on alignment; for now the important point is that instruction following as a capability is separable from alignment: a model can be highly capable at following instructions and poorly aligned, or less capable but better aligned.

A more recent class of emerging capabilities involves tool use: the ability to call external functions, search the web, execute code, or interact with databases. Models trained to use tools do not merely generate text describing what they would do. They invoke functions and process results.

This capability sits at the border between language understanding and agency. A model that can search for current information, run code to verify a computation, and synthesize results from multiple sources is doing something qualitatively different from text generation. It is operating on the world, not just describing it. The output of the model is no longer just text but a sequence of actions whose consequences extend beyond the context window.

The computational requirements for tool use are interesting to analyze. The model must represent the tool's interface (what arguments it takes, what it returns), decide when to invoke it, formulate a valid call, parse the result, and integrate it with prior context. Each of these steps involves a kind of structured reasoning that earlier models struggled with. That modern models can perform this reliably, even across unfamiliar tools described only in documentation, suggests the development of some general understanding of function interfaces as an abstract concept.

Tool use also enables a form of self-verification that pure text generation cannot achieve. A model that writes code and executes it gets immediate, reliable feedback. A model that performs a calculation and checks it with a calculator gets a ground-truth answer. This grounding to external reality makes tool-augmented agents more reliable in their specialized domains than models operating purely from internalized knowledge.