The evolution of Artificial Intelligence is often described as a series of architectural leaps. We moved from simple rule-based systems to machine learning, then deep learning, and now, the era of the Foundation Model. A recent, critical observation—termed "The Great Absorption" by *The Sequence*—suggests our next major architectural shift is underway: the transfer of complex, explicit system logic directly into the very structure of the largest AI models.
In simple terms, instead of building a separate, coded "brain" (the LLM) and then connecting it to many specialized "tools" or "helper programs" (the system code for planning, memory, or tool use), frontier models are starting to learn how to *be* those tools internally. This means the lines between the model weights and the system software are blurring, leading to monolithic, highly capable AI entities. This trend signals a profound change in how we design, deploy, and interact with intelligent systems.
For years, cutting-edge AI utilized a modular approach. An LLM might be brilliant at language, but if it needed to search the internet or calculate complex math, engineers would build external frameworks, often using techniques like Retrieval-Augmented Generation (RAG) or explicit function calling. These frameworks acted as the "system code"—the digital operating manual that told the LLM *how* and *when* to use external resources.
The Great Absorption flips this model. As models scale exponentially in size (more parameters), they seem to be developing implicit, generalized capabilities that mimic previously coded functionalities. They don't just learn *what* to say; they learn *how to structure* complex thought processes, planning sequences, and internal state management—tasks that required bespoke system code just a year ago.
To understand the magnitude of this shift, we need to look at three key areas: architectural debates, the nature of emergent intelligence, and the resulting impact on the traditional software stack.
The debate over how to build the most effective AI is heating up. Do we stick to the agile, modular approach, where small, specialized models or software components work together (like a team of experts)? Or do we bet on the monolithic approach, where one giant model handles everything?
The trend towards absorption strongly favors the monolithic side. When a model exhibits native planning capabilities—something traditionally outsourced to an external planning agent—it suggests that the architectural overhead of maintaining many separate components decreases. This leads us to search for analysis on this tension, examining the implications for system design.
If we consult industry discussions regarding this shift (searching for concepts like "Monolithic AI Models" vs "Modular AI Systems" implications), we see a realization: training a single, larger model might ultimately be more cost-effective and performant than orchestrating dozens of smaller, task-specific models.
For AI Engineers and Architects, this means that proficiency in orchestration frameworks (like LangChain or AutoGen) may gradually give way to expertise in model alignment, prompt engineering at scale, and deep understanding of massive model architectures (like Gemini or GPT-5 successors).
The key justification for the Great Absorption is the phenomenon of *emergence*. These complex system behaviors—like deep chain-of-thought reasoning or multi-step goal decomposition—were not explicitly programmed. They simply appeared once the models crossed certain thresholds of size and data exposure. This supports the argument that the "system code" is effectively being imprinted onto the neural network weights during training.
Research into "Emergent Capabilities in Foundation Models" confirms that as models scale, they spontaneously acquire abilities that were absent in smaller versions. This is the purest form of absorption: the functionality isn't added; it *grows* out of the complexity of the network itself. For researchers, this suggests that the path to AGI might be less about clever engineering and more about massive, focused scaling.
For the general reader, think of it this way: A child who reads enough books eventually learns how to structure an argument without needing a separate book on "Argument Structure Theory." The knowledge is woven into their understanding of language itself. Frontier models are doing the same with planning and execution.
Perhaps the most tangible consequence of the Great Absorption is its effect on traditional software development. If the LLM can natively handle data structuring, memory recall, error checking, and tool invocation, what happens to the layers of middleware, APIs, and explicit logic that developers used to write?
We see this explored when looking at the "Impact of highly capable LLMs on traditional software stack." The shift is away from writing boilerplate integration code and towards defining intentions via prompts and constraints. The future application may look less like a traditional MVC (Model-View-Controller) architecture and more like a single, highly constrained model orchestrating complex interactions.
This is revolutionary for businesses. Why hire a team to build, test, and maintain a complex microservice for inventory reconciliation when a single foundation model, properly constrained, can perform the task by reading source documents and writing the final transaction directly?
The Great Absorption is not just a theoretical concept; it has immediate practical consequences across industry verticals.
The need for traditional software engineers who glue services together will not disappear, but the focus will shift. Expertise in *model reasoning* and *safety engineering* becomes paramount. If the agentic capability resides in the weights, debugging becomes less about tracing execution paths in code and more about analyzing token probability and internal state vectors. We move from debugging syntax errors to debugging reasoning errors.
Businesses can anticipate a high degree of consolidation. Why maintain 10 specialized AI services when the next generation of foundation models can replace them all? This promises faster deployment cycles. Products that took months to build using modular agent frameworks might now be prototyped in weeks using advanced prompting and fine-tuning on a single powerful model.
However, this also introduces centralization risk. When all critical system logic is centralized in one massive, proprietary model, dependence on that model provider becomes extremely high. If the core weights shift their behavior subtly (a concept known as "model drift"), the entire system built upon it can fail unexpectedly.
This absorption deepens the "black box" problem. When system logic was explicit code, we could audit every step: "The code decided to use Tool X because input Y was present." When that logic is embedded in billions of parameters, verification becomes significantly harder. This is particularly concerning when dealing with sensitive applications like legal or medical diagnosis, where understanding *why* a decision was made is non-negotiable.
Furthermore, the consolidation of power into fewer, larger models intensifies the competitive landscape. As suggested by commentary on "The demise of specialized AI agents due to LLM scale," smaller, specialized AI companies relying on modular structures face an existential threat as frontier models ingest their core functionality for free, simply by scaling up.
How can leaders and builders prepare for a world dominated by these monolithic, self-contained intelligence engines?
The Great Absorption marks a pivotal moment. We are transitioning from an era of AI built by explicit assembly of components to an era of AI grown from sheer scale. The future of software development is less about writing instructions and more about nurturing an increasingly powerful, self-contained intelligence.