Last updated on January 29th, 2026 at 07:36 am
UPDATE: A third agentic model is beginning to emerge, one enabled via integration into a proprietary ecosystem (think Qwen, UCP, Manus and WeChat). It is likely that all three models (atomized, scaffolded and ecosystemed) will start to converge where possible. Count on increased separation of probabilistic function from everything else to enhance reliability a la Google GitHub.
- Atomized: task-level agents, tool calls, explicit orchestration
- Scaffolded: managed runtimes, guardrails, workflow layers
- Ecosystemed: agency emerging from tight integration into a closed platform (payments, identity, distribution, state)
The third path is the important update. Systems like Qwen, UCP, Manus, and WeChat don’t feel like agents because agency is distributed across the ecosystem rather than exposed as a discrete runtime. Ecosystemed agency will likely scale fastest because ownership of identity, payments, distribution, and enforcement substitutes for intelligence. Atomized and scaffolded agents still need to make decisions large and small. This makes it the most predictable and reliable, also includes the least real agency.
—–
Once upon a time way back in early 2023–2024, corporate audiences were entranced with visions of AI that could think autonomously, AI that would plan, decide, and act as if imbued with agency. Vendors spoke of agents “running your business” and “owning decision loops.” Gartner predicted that such systems would redefine enterprise software.
At first, this proceeded well. Developers added small automation layers on top of LLMs: simple prompt templates, output parsers, and application logic. These early extensions were modest, integrating GPT responses with a database or using a model to generate SQL queries. The models appeared powerful because they could produce human-like text and, with clever engineering, interact with structured APIs.
But the cracks began to show when researchers tried to build higher-order functionality: unattended task planners, self-directed workflows, or general decision makers. What seemed like logical inference degraded into error cascades. Models hallucinated facts, dropped or misinterpreted instructions, or contradicted themselves. The more open the task, the worse the performance.
As a result, builders started to control the context more tightly. They added validation layers, pattern matchers, guardrails, retry logic, constraint solvers, and fallback rules. They wrapped the model in deterministic execution engines and interleaved it with system state. In essence, they created what we now call scaffolding: external code that shapes, disciplines, and mediates the model’s output.
Over time, this pattern reversed the original perception of where intelligence resided. Instead of the LLM being the engine of autonomy, it became one component (frequently the interface for intent interpretation and surface-level reasoning) but surrounded by deterministic, engineered logic. Task orchestration, error handling, resource coordination, and policy compliance almost always lived in traditional code.
As the technology has matured, practitioners, researchers, and industry leaders have collectively reassessed what “agentic AI” actually is in practice. Across conferences, engineering blogs, product launches, and internal architectural discussions, a reluctant consensus has emerged: what we call agentic AI is overwhelmingly scaffolding wrapped around a predictive model. The intelligence that matters, the part that seems like agency, is not inside the model at all but in the systems engineering that envelops it.
This shift became explicit in industry discourse, especially with the advent of “agentic AI” frameworks like ReAct, Toolformer, and product implementations such as OpenAI’s tool ecosystem, Anthropic’s Claude with plugins, and Alibaba’s Qwen App. These frameworks emphasize that the model is only capable of predicting the next best action symbolically, not decide actions purely on its own.
The industry has gradually acknowledged that, to make AI useful in real world applications, it must be tethered or have highly atomized decision flow; orchestrated by systems engineering that enforces correctness, safety, consistency where necessary. The model becomes a component in a larger architecture: it parses intent, generates structured suggestions, and fills parameters, but the surrounding scaffold interprets, verifies, and executes.
This shift is evident across multiple proof points. Salesforce’s Agentforce pricing structure has shifted away from consumption back to seats, demonstrating a lack of uptake. Nick Bustamante’s analysis of governance complexity in financial services agents revealed that compliance frameworks require elaborate supervisory layers; procedural guardrails that exist entirely outside the model itself. Meanwhile, “atomized” agents, or highly contained sequences where agentic logic is broken up sequentially, have become popular. Approaches from the new eCommerce standard Unified Compute Platform and Google’s collaborations with GitHub demonstrates deliberate architectural choices to decompose agent functionality into specialized, coordinated components rather than relying on monolithic model reasoning. Booking.com’s case study perhaps best exemplifies this trend, showcasing how production-grade agents depend on extensive workflow orchestration, API integrations, and deterministic business logic wrapping relatively straightforward LLM calls. The narrative has shifted from “AI that thinks for you” to “AI that helps you, embedded in systems that manage complexity.”
There are two emerging models, 1. atomized and 2. ecosystem. Both are variations on high degrees of architecture to compensate for a simple architectural issue: transformers are not built for autonomy. They are built for probability and inference. Quality of scaffolding has become the primary driver of production value.
The atomized agent model, used in systems like Google’s developer tooling partnerships and Universal Control Plane–style (UCP) orchestration, breaks agents into tiny digestible bits of flow-driven actions. In this approach, there is no single “agent” with broad autonomy. Instead, narrowly scoped micro-agents handle discrete tasks (intent parsing, retrieval, validation, execution) each tightly constrained, stateless, and supervised by deterministic control logic. The language model is invoked opportunistically, often as a classifier, translator, or parameter generator, while the surrounding system manages state, sequencing, and correctness. This model reflects an explicit rejection of long-horizon autonomy in favor of composability and reliability.
The second model, exemplified by Alibaba’s Qwen, is ecosystem-centric rather than agent-centric. Here, the appearance of agency comes from deep vertical integration: commerce, payments, logistics, maps, and identity are already unified, and the model’s role is to translate user intent into executable calls across a pre-existing, highly deterministic service graph. Qwen does not reason its way through open-ended planning; it routes intent through a closed, well-defined operational universe. Both models reach the same conclusion by different paths: agency does not live inside the model. It is either decomposed into tightly governed components or delegated to an industrial-grade service substrate, with the model acting as a thin reasoning layer at the interface.
This pattern answers the key question: Why do models still hallucinate, contradict themselves, fail at multi-step planning, and struggle outside narrow domains? Because they were never architected to hold goals, simulate sequences of actions across extended horizons, or evaluate consequences with a stable world model. They predict text; still struggle with ambiguity complexity and sequentiality of action; they do not possess agency.
The surrounding scaffolding does much of the heavy lifting necessary for reliable operation. It provides:
- State management: Tracking workflow progress and context outside the model.
- Validation rules: Ensuring outputs conform to structural and semantic constraints.
- Execution orchestration: Triggering external services through deterministic APIs.
- Error recovery: Handling failures with rules, retries, and safe fallbacks.
- Security and compliance: Enforcing access control, privacy filters, and policy checks.
Without these layers, the model’s performance degrades quickly — especially in real-world settings where ambiguity, incomplete information, or requirement drift is common.
The reasoning in language models is not, ironically, sonething based in agency. They clearly manifest abilities that resemble reasoning; relational inference, analogy, arithmetic patterns, and even procedural descriptions. But these are contextual inferences, superficial approximations, and statistical generalizations rather than deep, internally coherent cognitive processes. They are small reasoning kernels, not autonomous minds.
The industry’s consensus, explicit or implicit, is that scaffolding is not a temporary crutch but a fundamental architectural necessity. We have shifted from imagining standalone AI agents to building composite systems where models interact with engineered frameworks to deliver effective outcomes.
Understanding this reality changes how we should evaluate agentic AI:
First, it corrects expectations. Real-world AI is not a general autonomous thinker; it is a highly capable component in a hybrid system.
Second, it suggests where innovation will continue to matter most: in the quality of scaffolding — orchestration frameworks, safety layers, modular APIs, stateful execution engines — not just in larger, more parameter-rich models.
Third, it reframes AI research priorities. If reasoning is emergent and distributed across model plus scaffolding, then breakthroughs will likely come from integrated system design, hybrid symbolic-neural architectures, and structured execution frameworks rather than from scaling model size alone.
This scaffolding primacy is further validated by emerging performance metrics like the Evans Ratio, which measures the balance between probabilistic model outputs and deterministic code in agent systems, and the Brock Threshold, the theoretical inflection point at which this ratio fundamentally shifts in favor of probabilistic code. We have not seen a probabilistic agent deployed in enterprise production yet. The prediction flowing from this pattern is stark: we should not expect current transformer-based LLM architectures to escape this scaffolding dependency. The fundamental limitation isn’t training data or parameter count—it’s that these architectures lack native mechanisms for reliable multi-step planning, persistent memory management, and deterministic tool use. Until we see architectural innovations that internalize what scaffolding currently provides externally, perhaps through integrated retrieval, built-in execution environments, or verifiable reasoning modules, production agents will remain primarily engineering systems that happen to include LLMs, rather than LLMs that happen to need some engineering support.
If the industry has now converged on two viable models for agentic AI, the atomized agent architecture and the ecosystem-integrated model, the strategic options are stark. Ecosystem-based agency carries an extraordinarily high barrier to entry: it requires ownership of payments, identity, logistics, marketplaces, and fulfillment, not just better models. Alibaba can make Qwen feel agentic because Alibaba already controls the world in which Qwen operates. Most companies do not. That reality is precisely why atomized architectures like UCP are likely to matter so much outside closed mega-platforms. By embedding orchestration, permissions, and execution across a pre-assembled commercial substrate, UCP offers something rare: atomized agentic capability within an adoptable ecosystem. In e-commerce especially, where transactions, identity, inventory, and trust already exist as interoperable primitives, this hybrid approach may prove powerful. Qwen proves agency scales via ownership, not intelligence, and UCP suggests a path for those who do not own the world to still act within it.
Model Context Protocol (MCP) like UCP is emerging as a hybrid decisive inflection point in how agentic systems are built and governed: atomization powered by scaffolding, or scaffolding enabled by atomization. Rather than treating “agents” as free-roaming prompt constructions that infer how to use tools, MCP formalizes the relationship between a model and the external world through explicit schemas, permissions, and execution boundaries. This shifts agency away from improvisation and toward infrastructure: tools are declared, actions are scoped, and execution is separated from reasoning. The result is not more intelligence, but more control. In a landscape where many agentic systems blur autonomy and risk, MCP represents a move toward bounded agency—where systems can act, but only within clearly defined, auditable constraints. That distinction is likely to matter far more at scale than any single model breakthrough.
For enterprise leaders, the lesson is straightforward. The era of “autonomous AI agents” should not be evaluated as a test of model intelligence, but as a test of system design, governance, and integration discipline. The most effective agentic systems in production today succeed not because models think independently, but because organizations have engineered reliable scaffolding around narrow reasoning capabilities. Whether through atomized architectures or ecosystem-based execution, real value comes from ownership of workflows, data, permissions, and trust, not from chasing illusory autonomy. We are not in an era of hand the keys to the model and let it run; not yet. The Qwen model demonstrates agency scales via ownership, not intelligence.
For B2B organizations, the competitive question is no longer how intelligent a model appears in isolation, but how well AI can be embedded into existing operations to execute safely, predictably, and at scale.
