What is AGI, and is it really around the corner?

We observe systems that demonstrate superhuman aptitude in narrow domains, yet fail at tasks requiring what seems to be trivial common sense or memory. One popular framing suggests the path to AGI is blocked not by a need for more scale, but by a set of “engineering problems”: we lack persistent memory, robust agentic scaffolding, and effective long-term planning frameworks. The underlying assumption is that the core intelligence, the Large Language Model, is a sufficiently powerful cognitive engine, and we must now simply build the correct chassis around it.

This framing feels incomplete. It seems to mistake a symptom for the disease. The reason current models lack these capabilities is not an incidental engineering oversight. The limitation is inherent to the architecture itself. The very concept of “bolting on” memory or agency to a pretrained transformer is a category error, rooted in a misunderstanding of what these models are. We are trying to engineer around a foundational property, not supplement a feature-incomplete system.

To clarify this, we need a better distinction than “model training” versus “engineering”. The critical distinction is between what I will term Inscribed Architectures and Adaptive Architectures.

Current frontier models, from GPT-5 to Claude 4, are Inscribed Architectures. The entirety of their pretraining and fine-tuning process is a monumental effort to inscribe a compressed, high-dimensional representation of their training data into a fixed set of weights, $W$. Inference is the process of navigating this static, inscribed manifold. A prompt is a starting vector, and the autoregressive process is a trajectory through this pre-computed space. The model’s “knowledge” is not a set of retrievable facts but the very geometry of this manifold. RLHF and constitutional AI do not change this; they merely warp the manifold to make certain trajectories more probable and others less so. The context window, even when extended to millions of tokens, does not represent learning. It is a temporary, local distortion of the activation space, which vanishes the moment the session ends. The underlying inscription $W$ remains untouched.

An Adaptive Architecture, by contrast, is one where interaction with the environment produces durable and efficient updates to the model’s core parameters $W$. This is not the same as continual fine-tuning, which is computationally expensive and risks catastrophic forgetting. An adaptive process, $W_t -> W_{t+1}$, would be an intrinsic function of the model, operating continuously and locally as it processes new information. This is the architectural property that gives rise to what we call continual learning. A human does not learn to play the saxophone by receiving a refined set of instructions for the next attempt. Each breath, each note, and each error provides a feedback signal that physically alters their neural substrate. Their $W$ is in constant flux.

The “engineering” solutions currently being pursued are attempts to simulate properties of adaptive systems using an inscribed core. RAG is a way to project external data into the temporary context window, simulating factual recall without updating the world model. Chain-of-thought prompting forces the model to traverse a longer, more structured trajectory within its inscribed manifold, simulating reasoning without genuine deliberation. These are clever and useful techniques, but they are building scaffolding around a fundamentally static object. The scaffolding can never change the nature of the object itself. It will always be brittle at the interface.

This reframing helps us understand why progress can feel both miraculous and stagnant. For any task that can be well represented within the inscribed data manifold, performance will be extraordinary. This is interpolation on a cosmic scale. But for tasks that require the construction of new knowledge, the durable accumulation of context, or the revision of core beliefs based on novel evidence, the architecture has no native mechanism. The model cannot learn, in any meaningful sense of the word, because its parameters are frozen. It can only perform.

The implications for AGI are significant. If AGI is defined as a system that can autonomously learn and adapt across a wide range of domains, then inscribed architectures are a dead end. No amount of scaling or clever scaffolding will bridge this fundamental gap. The resulting system will be a more and more comprehensive map of its training data, but it will never become a map-maker. It is a system that has been given a perfect memory of a library, but no capacity to write a new book.

This also sharpens our view of alignment. Aligning an inscribed model is a problem of constraining its outputs, of fencing off undesirable regions of its static knowledge manifold. Aligning an adaptive model is a problem of aligning its update rule: the very process by which it modifies its own cognition. The latter is a far more complex and dangerous problem, one that involves understanding the dynamics of a self-modifying mesa-optimizer. We are currently struggling with the former, which should give us pause about the prospect of building the latter.

Our present focus on engineering modules around a static core may be a necessary research step, but we should not mistake it for the path to AGI. We need to be asking more fundamental questions. What architectural primitives would even support efficient, durable, local weight updates? How can a system learn to modify its own structure without succumbing to instability? These are questions of computer science and neuroscience, not software engineering. Until we can move from inscribed to adaptive architectures, AGI will not be “right around the corner”. We will simply be building ever-more-elaborate puppets, with no ghost in the machine.