The Great Unbundling (April–September 2024)

Chapter 6 The Great Unbundling (April–September 2024)

On April 24, 2024, a senior vice president at Amazon Web Services stood before a developer audience and delivered a quiet declaration of war. He was announcing AWS Bedrock Agents. His statement was precise.

The “agent harness,” the collection of protocols, loops, and frameworks that had emerged over the previous year to coordinate AI models with tools and memory, was not a new, independent layer in the software stack. It was, he asserted, “a feature of the cloud control plane.” With this launch, AWS repositioned its existing infrastructure—its model garden, its serverless compute, its identity and access management—as the natural, inevitable substrate for building AI agents. The move was not an addition but an absorption.

It crystallized a fracture that had been spreading since the protocol turn of early 2024. That turn had not settled the harness layer. It had shattered it. Back in the first months of the year, the hopeful narrative had been one of convergence. OpenAI’s function calling and Anthropic’s tool use had standardized how a model requested a tool.

The independent frameworks, having evolved from prompt chains to protocol managers, seemed poised to become the neutral switchboard of the AI era. But convergence assumed the new layer would be allowed to exist as a neutral middle.

Instead, every platform with a stake in the outcome—the model vendors, the cloud providers, the framework companies—looked at the embryonic harness and saw the same prize: the next operating system. Each began pulling it into their own orbit, defining that OS in a way that secured their own strategic dominion.

Over the next six months, the agent stack unbundled into a set of warring platform visions. This unbundling was not a market failure. It was a structural inevitability. The harness layer had become valuable enough to attract platform capture, yet too fragmented and nascent to resist it. The scaffolding paradox, first seen when model APIs absorbed tool-calling protocols, was now playing out at a higher, more consequential level. The winners of the protocol turn became the primary targets of the ensuing land grab. The fracture unfolded along three primary fronts.

The first front was the model vendors’ offensive, a campaign of quiet deprecation. OpenAI’s Assistants API, launched in late 2023, was more than a feature set; it was a philosophical statement. It provided a native runtime where an agent could live, with built-in file search, a code interpreter, and function calling. Throughout early 2024, its development trajectory showed a clear pattern: it steadily incorporated capabilities that had once been the unique selling points of independent frameworks. In April, it added persistent threads, giving agents conversational memory that spanned multiple interactions—removing the need for developers to manage session state externally. The vision was a closed loop: developers would use OpenAI’s models, its orchestration runtime, and its growing ecosystem of first-party tools. The friction of choosing a framework was to be engineered away.

Anthropic followed a parallel path with the systematic rollout of “Tool Use” and then “Computer Use” for its Claude models. These were not mere API features but architectural claims. They framed the model itself as the natural, intelligent orchestrator, capable of natively planning and executing complex, multi-step tool-using workflows. Anthropic’s argument was that a separate, generalized orchestration layer was an unnecessary abstraction—a source of latency, complexity, and failure. The harness logic belonged inside the model’s core competency.

For developers, the appeal was potent. For the independent harness companies, it was an existential threat. Each enhancement to these native runtimes chipped away at the rationale for a standalone framework. This absorption was the scaffolding paradox in its purest form. The harness inventions of 2023—standardized tool calls, reasoning loops—were being swallowed by the very models they were built to control. The companies that had pioneered those inventions now faced a stark choice: climb the stack or watch their layer evaporate.

The cloud hyperscalers opened the second front. Their countermove was one of rebranding and integration.

They did not need to invent a new harness; they needed only to expose the one they already owned. AWS Bedrock Agents, announced that April day in Las Vegas at re: Invent 2024 (the event’s actual date), was the definitive expression of this strategy.

It integrated natively with Google’s search and grounding services, positioning the agent as a natural extension of its data and AI platform. Microsoft’s entry, through its Copilot Studio and Azure AI Agents, leveraged its deep integration with the Microsoft 365 ecosystem. The agent was becoming a feature of the suite, the cloud, the platform. It was not a new kingdom to be built. It was a province to be annexed.

This hyperscaler push reshaped the metering of trust. Security, permissions, and cost controls were no longer problems for the harness developer to solve with custom code; they were checkboxes in a cloud console. The unit of sale for autonomy shifted from technical capability to policy configuration. A developer could buy a slice of trust, pre-packaged with the cloud provider’s compliance certifications and spending limits. This convenience came with a trade-off: the protocols for how agents worked were now being defined by the cloud vendors’ internal architectures, not by open community standards. The third front was the scramble of the independent framework companies and open-source projects.

Caught in the pincer movement of model-vendor absorption and cloud-provider envelopment, their survival tactic was to climb higher. If the base layer of tool calling and single-agent loops was being swallowed, then they would build on the floor above. They abandoned pure protocol ambitions for full orchestration platforms, promising multi-agent coordination, persistent memory systems, and cross-model portability. They argued that the real complexity lay not in making one agent work, but in making many agents work together reliably—a problem neither the model labs nor the cloud providers were incentivized to solve in a vendor-neutral way.

LangChain, the framework that had ridden the 2023 gold rush, pivoted sharply in this period. Its repository still boasted tens of thousands of stars, but its original promise of being the universal connector between models and tools was under direct assault from the native APIs. LangChain’s response was LangGraph, announced in the spring. It was a library for building stateful, multi-agent workflows—a deliberate move up the stack from protocol management to choreography.

The company began talking less about chains and more about supervision, human-in-the-loop approval nodes, and agentic workflows that mimicked organizational processes. The climb was explicit. Other independents followed similar trajectories. Smyth, CrewAI, and a host of smaller projects all converged on the language of orchestration. Their marketing materials began to feature diagrams not of single agents interacting with APIs, but of teams of specialized sub-agents passing tasks and results between them, overseen by a managerial agent. The scale of the problem had been redefined upward. The battleground was no longer a single loop, but the factory floor.

This three-way fracture was not a chaotic free-for-all. It was a logical, almost mechanistic redistribution of pressure following the protocol turn. Each camp’s moves were predictable from its strategic position. The model vendors sought to own the intelligence core and its immediate interface. The cloud providers sought to own the operational substrate. The independents, with no infrastructure or core model to leverage, sought to own the coordination logic that sat between them.

The result was a stack that was not layering neatly, but delaminating. Amid this platform warfare, one domain proved not only resilient but ascendant: programming. Here, the Ground-Truth Law found its most powerful expression. An agent writing code received immediate, verifiable feedback. The code either compiled or it didn’t. The tests passed or they failed. There was no ambiguous interpretation of a customer’s email, no subjective analysis of a legal document. The feedback loop was binary and fast. This made programming the killer domain for autonomous agents, not because the models were inherently better at code, but because the harness could be simpler and its results could be trusted more quickly.

The trajectory of GitHub Copilot demonstrated this. Launched in 2021 as an autocomplete tool, it had evolved by 2024 into a proactive coding agent integrated directly into the IDE. Its harness was minimal but perfectly tuned to the ground-truth environment. It observed the developer’s existing code, made suggestions, and the developer accepted or rejected them. The metering of trust was granular and continuous—each suggestion required a keystroke of approval.

The entire system was built on a protocol: the LSP, or Language Server Protocol, which standardized how tools interact with code editors. The success of Copilot created a de facto standard for how AI interacted with the developer’s workspace, a clear case of Protocol Politics playing out in a focused domain.

Cursor, an AI-native code editor that emerged in 2023, took this further. It built its entire interface around the agent, treating the editor not as a text buffer but as a collaboration surface with an AI pair programmer. Cursor’s innovation was to make the agent the primary interface, with the human in a supervisory role. Its harness was the editor itself. This tight integration gave it an advantage over broader frameworks trying to operate generically across domains. Cursor showed that the most effective harness was often a vertically integrated one, designed for a single, ground-truth-rich environment.

The ultimate test of this principle came from benchmarks like SWE-bench, which evaluated AI agents on their ability to solve real GitHub issues.

The top performers in mid-2024 were not general-purpose agents using sprawling frameworks. They were coding-specific systems with tightly constrained loops: fetch an issue, analyze the codebase, propose a patch, run the tests, iterate. The harness was engineered to maximize the signal from the ground truth of the test suite.

This domain success, however, also made it a prime target for absorption. Claude Code, Anthropic’s coding-specific model, and continued advances in OpenAI’s code interpretation capabilities represented the scaffolding paradox in action: the specialized coding harness was being baked into the models themselves.

The great unbundling of April to September 2024 was therefore a story of simultaneous fragmentation and conquest. The overall harness layer splintered into competing visions, but within specific, high-ground-truth domains like programming, integrated platforms began to coalesce and dominate.

This created a stark dichotomy for developers. For a coding agent, they might choose a tightly bound, all-in-one environment like Cursor or rely on an increasingly capable native model feature.

For a customer service agent parsing natural language, they faced a bewildering matrix of choices: build on a cloud provider’s agent builder, use a model vendor’s Assistants API, or assemble a custom orchestration platform from independent tools. The cost of choosing wrong was not just technical debt, but the risk that the layer they built upon would be absorbed out from under them.

By late summer, the consequences of these choices were materializing in the fortunes of the companies involved. The independent framework companies were bifurcating into survivors and casualties. The survivors were those that had successfully climbed to a higher-order problem—orchestration, multi-agent systems, audit trails—and had done so with enough speed and clarity to attract a developer constituency that needed vendor-neutral solutions. The casualties were those that remained at the protocol level, competing directly with the now-good-enough native capabilities from OpenAI and Anthropic. Their GitHub traffic stagnated. Their venture funding slowed. Their raison d’être was evaporating. The cloud hyperscalers, for their part, were engaged in a land grab measured in developer registrations and consumption metrics.

Their battle was less about the brilliance of their agent technology and more about the inertia of their existing ecosystems. A company already running on AWS was far more likely to try Bedrock Agents. A Microsoft 365 shop would naturally look at Copilot Studio. The agent harness became another lever for platform lock-in, another service on the monthly bill. The cloud providers competed on the breadth of their model gardens, the depth of their pre-built tool integrations, and the tightness of their security wrappers. Their success was judged not by breakthroughs in agentic reasoning, but by adoption curves within their own walled gardens.

The model labs watched this with mixed feelings. On one hand, their native agent runtimes were seeing rapid uptake. On the other, the cloud providers were effectively reselling their models, bundling them into larger packages, and capturing the direct customer relationship. The economic tension of the harness layer—who captured the premium for turning a talking model into a working system—was being negotiated in real time.

Would the value accrue to the intelligence provider (the model lab) or the intelligence operator (the cloud platform)? The unbundling ensured that, for now, both would try to claim it.

As September ended, the landscape was one of settled trenches rather than open warfare. The fronts had stabilized. The model vendors owned the core agent runtime. The cloud providers owned the operational infrastructure and the enterprise customer. The independents owned the advanced orchestration tools for complex, multi-agent use cases. No single party owned the harness layer; instead, each owned a slice of it, defined according to their strategic advantages.

This fragmentation had a wearying effect on the broader developer community. The initial promise of the harness was that it would abstract away complexity, providing a standard way to make AI work. The reality of the great unbundling was a proliferation of incompatible standards, each demanding its own investment of time and faith. The pragmatic response, visible in countless forum threads and project post-mortems, was a retreat to simplicity.

This absorption at the model layer was neither accidental nor superficial; it represented a fundamental reassertion of the intelligence core’s sovereignty.

The strategic imperative for OpenAI and Anthropic was clear. As the agentic paradigm gained traction, the value was migrating from simple model inference to the orchestration logic that made that inference actionable. To allow a neutral third-party layer to capture that value would be to cede control over the application ecosystem and, ultimately, the developer relationship.

Their native runtimes were engineered not just for capability but for capture. Every feature added—persistent threads, integrated file search, built-in code execution—was a deliberate simplification that erased a pain point previously addressed by external frameworks. The friction removed was the market opportunity eliminated.

For developers, the appeal was undeniable: a cohesive, supported, and often cheaper-to-start environment where the model and its handler were designed in concert. For the independent harness companies, each such enhancement was a quiet, systematic erosion of their foundation. The scaffolding paradox manifested not as a single catastrophic event, but as death by a thousand convenient features.

The cloud hyperscalers’ strategy, meanwhile, was one of infrastructural envelopment. Their power derived not merely from bundling, but from the sheer gravitational mass of their existing services.

When AWS positioned the harness as “a feature of the cloud control plane,” it was making a technical and commercial assertion. Technically, Bedrock Agents was a configuration wizard that stitched together long-standing AWS primitives: Lambda functions became tool executors, S3 buckets turned into knowledge bases, CloudWatch logs served as agent audit trails. The innovation was in the packaging, not the invention.

Commercially, this allowed AWS to meter and monetize agentic activity through the same channels as any other cloud resource—by compute-seconds, data-transfer gigabytes, and API calls. The harness became a new consumption vector for old services, locking the high-margin orchestration logic into the cloud provider’s billing and support ecosystem.

Google and Microsoft executed variants of the same playbook, leveraging their respective monopolies in search and enterprise productivity software. The agent was not a new product category to sell, but a new reason for customers to deepen their dependency on an existing platform’s full suite.

The battle among hyperscalers therefore centered on whose garden had the most attractive pre-integrated tools and whose compliance certifications most easily soothed anxious enterprise procurement departments.

Trapped in this pincer movement, the independent frameworks faced a Darwinian pressure to evolve or perish. Their climb to higher-order orchestration was a desperate and logical adaptation.

If the base protocols of tool calling and single-agent loops were becoming commoditized, then their unique value had to reside in managing the complexity that emerged between agents.

This shift from protocol management to choreography was a qualitative leap. Frameworks like LangGraph began to offer constructs for distributed agent workflows—supervisory agents, failover paths, competitive sub-agent swarms—that modeled software engineering patterns or even organizational charts. This addressed a genuine and growing need, as early adopters of agentic AI stumbled upon the chaos of managing multiple, interacting autonomous processes.

The independents argued, with some validity, that neither model vendors nor cloud providers were incentivized to build truly vendor-neutral, cross-platform orchestration. A cloud provider’s multi-agent system would naturally prefer its own models and tools; a model vendor’s system would optimize for its own intelligence core. The independents’ newfound niche was the polyglot and portable coordination layer, a claim to neutrality that was their last, best moat.

This three-front war reshaped the very definition of what constituted an “agent platform.” For model vendors, it was an intelligence-centric runtime. For cloud providers, it was an infrastructural control plane. For independents, it was a vendor-agnostic coordination engine. This trichotomy forced developers into a series of consequential, identity-defining choices. Selecting a path was not merely a technical decision, but a strategic bet on which vision would dominate—and which layer would retain the most value and autonomy over time. The fatigue that set in by late summer was the fatigue of premature standardization, of choosing a side in a war whose front lines were still being drawn. Developer forums filled with lamentations about sunk costs in a framework that was suddenly competing with its own supplier’s native features, or about the daunting complexity of migrating an agent from one cloud’s walled garden to another’s.

The ascendance of programming as the killer agent domain threw this fragmentation into sharp relief. Here, the environment itself enforced a discipline that made the harness question simpler. The ground-truth feedback loop of a compiler or test suite acted as a natural, unforgiving harness, reducing the need for bespoke orchestration logic.

Consequently, the most successful coding agents were those that integrated most tightly with this environment, like Cursor embedding the agent directly into the editor’s fabric, or GitHub Copilot leveraging the Language Server Protocol. This vertical integration worked precisely because the domain was constrained and the feedback unambiguous.

It offered a glimpse of a possible future for other domains: not a universal harness, but a series of domain-specific, vertically integrated platforms where the environment and the agent were co-designed.

However, this very success made the coding harness a ripe target, as seen with Claude Code, initiating a new cycle of the scaffolding paradox even within this sanctuary of ground truth.

Thus, by September 2024, the great unbundling had generated not cohesion but a hardened landscape of proprietary stacks. The initial dream of a standard, interoperable harness layer had dissolved into a pragmatic, if fragmented, reality of competing platforms. Each camp had solidified around its core competency, and the bloodletting of the summer had separated the viable strategies from the obsolete ones. The independents that survived were those that had moved fast enough up the stack to claim a new, complex problem space. The cloud providers had successfully turned agents into a retention tool for their broader ecosystems. The model vendors had defended their right to own the intelligence runtime. The period had begun with a declaration that the harness was a cloud feature, and it ended with the understanding that no one owned the harness at all—it had been disaggregated and its pieces claimed by the dominant platforms that surrounded it.

</think>The choices each camp made were not merely reactions to market pressure but deeply informed by their institutional histories and core business logics. The model vendors, born from a culture of research-centric product development, approached the harness as an extension of the model’s reasoning capability. Their runtimes were designed to minimize “impedance mismatch” between the model’s intent and its execution, a technical optimization that doubled as a commercial moat.

Developers opted for the simplest harness that could possibly work: often the native runtime of their chosen model, or the agent builder of their incumbent cloud provider. The grand, unified theory of the harness was deferred in favor of practical, if limited, solutions.

The scaffolding paradox, however, guaranteed this could not be the end. The absorption of one layer simply shifted the competition to the next. As model vendors baked in basic orchestration, the independents climbing the stack began to build the very features—multi-agent collaboration, persistent memory, complex workflow control—that would themselves become targets for the next wave of absorption. The climb was endless. The only alternative was extinction.

In a quiet corner of GitHub, a repository for a once-prominent framework project was archived by its maintainer in early September. The commit message was succinct: “Native APIs do this now.” The project had pioneered a clever system for managing conversational context for agents, a system made entirely redundant by the persistent threads feature of the Assistants API.

The code was left public, a monument to a layer that had been successfully swallowed. For anyone still building on the harness frontier, the message was clear: build not for what the models can do today, but for what they will hunger for tomorrow. The race was not against competing frameworks, but against the inevitable expansion of the platform below.