The Framework is NOT the Point!

Why the agentic tooling wars are the wrong argument – and what the frontier labs, the founders, and the data are actually telling us

Short-term turbulence for long-term abundance.

There is a particular kind of paralysis that afflicts anyone trying to build an agentic system in 2026. You open a browser. You start reading. Within twenty minutes you have seventeen tabs open – LangChain, LangGraph, CrewAI, AutoGen, Semantic Kernel, the OpenAI Agents SDK, DeepAgents, Microsoft’s newly-minted Agent Framework – a fistful of bookmarked essays, and rather less clarity than you began with. IBM’s developer advocacy team captured this beautifully in a recent explainer, and their prescription is exactly right: stop asking which framework is best, and start asking what kind of system you are trying to build.

I want to go a step further. Having spent the better part of three decades around this field – and the last two years building agentic deliverables for financial-services and insurance clients across fourteen Asia-Pacific markets – I have come to a slightly heretical conclusion. The framework is not the point. It never was. The framework is the most visible, most argued-about, and least decisive variable in whether your agentic system survives contact with production. We are having a loud argument about the steering wheel while quietly ignoring the fact that most of these cars never leave the driveway.

Let me make the case, using the best available evidence from the people who actually build this machinery.

Part One: What we are even arguing about

Before we referee the tooling debate, we need a shared vocabulary, because a great deal of the confusion is definitional rather than technical.

Anthropic drew the cleanest line in its now widely-cited engineering essay Building Effective Agents. It distinguishes between workflows – systems where language models and tools are orchestrated through predefined code paths – and agents, where the model dynamically directs its own processes and tool usage, retaining control over how it accomplishes a task. Everything else is commentary. In a follow-up on context engineering, Anthropic went further and offered the most useful one-line definition I have encountered: an agent is simply an LLM using tools in a loop. The field, they noted, has largely converged on this. As the models get smarter, the loop can be trusted with more autonomy.

That distinction — predefined path versus model-directed loop — matters more than any brand name, because it maps directly onto the trade-off every architect actually faces: predictability versus flexibility. Workflows give you consistency and auditability for well-defined tasks. Agents give you adaptability where the path cannot be hardcoded but progress can still be verified. Anthropic’s central counsel, which I wish were tattooed on the inside of every innovation team’s eyelids, is to find the simplest solution that works and only add complexity when it demonstrably earns its place. For a great many applications, a single well-constructed model call with good retrieval and a few in-context examples is entirely sufficient. The most successful implementations they observed were not using elaborate frameworks at all; they were using simple, composable patterns.

Onto that spine, Andrew Ng added the flesh. His four agentic design patterns — Reflection, Tool Use, Planning, and Multi-Agent Collaboration — remain the most serviceable mental model going, two years on. Reflection is the model critiquing and revising its own output, automated code review for its own reasoning. Tool use connects it to the world. Planning decomposes a goal into executable sub-tasks and adapts when reality intervenes. Multi-agent collaboration assigns distinct roles to specialised instances, much as a firm hires different people for different jobs. The sophistication, Ng notes, comes from combining them: plan to decompose, use tools to gather, collaborate to generate and critique, reflect to refine. It is telling that a year after he published these, the pattern-catalogue had ballooned — Anthropic’s five workflow patterns, community catalogues running to twenty-one and beyond — but Ng’s original four still frame the conversation.

OpenAI, in its Practical Guide to Building Agents, contributed the orchestration vocabulary most teams now use: the single-agent-with-tools system as the sensible default, and when you outgrow it, two multi-agent topologies — the manager pattern, where a central orchestrator calls specialised agents as tools, and the decentralised pattern, where peer agents hand off execution to one another. Their guidance echoes Anthropic’s: a single agent, with tools added incrementally, handles far more than people assume. Split it up only when the prompt logic becomes unmanageable or the tools begin to overlap and confuse the model.

So the frontier labs, for all their competitive theatre, agree on the fundamentals. Start simple. Add agency only when flexibility outweighs the cost in latency, expense, and compounding error. Reach for multiple agents last, not first. That consensus is the single most important and least fashionable finding in this entire field.

Part Two: The founders have moved on from the framework

Here is where it gets interesting. The people who built the frameworks are, increasingly, telling you not to fixate on them.

Harrison Chase, LangChain’s co-founder and chief executive, wrote a characteristically sharp essay in April 2025 titled How to Think About Agent Frameworks, partly in response to what he considered some misguided takes in OpenAI’s guide. His argument cuts to the bone: the hard part of building reliable agentic systems is making sure the model has the appropriate context at each step — controlling both what goes into the model and the steps taken to generate that content. Most frameworks, he observed, are neither declarative nor imperative orchestration engines; they are just a bag of agent abstractions. Those abstractions help you start quickly but can obscure the very thing that determines success — the context — and make it harder to control at exactly the moment control matters most.

By late 2025, Chase had refined this into a taxonomy I find genuinely clarifying, because it dissolves a false argument. He distinguishes three things people lazily bundle together as “frameworks”:

An agent framework (LangChain itself) provides abstractions — mental models that make it easy to get started and standardise how teams build.
An agent runtime (LangGraph) is the production substrate — durable execution, streaming, human-in-the-loop, persistence. Its true peers are not other agent libraries but general-purpose durable-execution engines such as Temporal and Inngest.
An agent harness (LangChain’s DeepAgents, and by analogy Anthropic’s Claude Agent SDK) is the batteries-included layer on top: default prompts, opinionated tool handling, planning tools, filesystem access — “a general-purpose version of Claude Code,” as Chase puts it.

This is not pedantry. It reframes the choice. You are not picking one framework and marrying it. You might author logic in a framework, run it on a runtime, and wrap it in a harness — three decisions, three different sets of trade-offs, mostly composable. The industry’s own language is separating the design surface from the execution substrate from the opinionated defaults, which is precisely the maturation you would expect as the field moves from experimentation to operation.

João Moura, CrewAI’s founder, put it more provocatively still. “Agent Harnesses Are Dead. Long Live Agent Harnesses,” he wrote, revisiting a line he had used on stage at a DeepLearning.AI conference: frameworks are cheap. A few people in the audience shifted uncomfortably; he thinks the statement has aged well. His point is that the durable value was never in the abstraction layer — it is in what you build, deploy, monitor, and iterate on top of it. Which is, not coincidentally, exactly the layer CrewAI now sells: an enterprise platform on top of an open-source framework that, by the company’s own account, executes vast numbers of multi-agent runs for a substantial share of the Fortune 500. Whatever one makes of the marketing, the strategic signal is unambiguous. The framework is table stakes. The money, and the difficulty, are elsewhere.

Even Microsoft’s consolidation tells the same story from the opposite direction. In October 2025 it merged AutoGen — the research project that popularised multi-agent orchestration — with Semantic Kernel, its enterprise SDK, into a single Microsoft Agent Framework, reaching its production-ready 1.0 in early 2026 with stable APIs, long-term support, and native A2A and MCP interoperability. Two of the five frameworks IBM’s video lists as distinct options are now one thing. The proliferation everyone finds so paralysing is already, quietly, consolidating.

Part Three: Why none of this is where your project will die

Now the uncomfortable data. Because if the framework debate were decisive, we would expect framework choice to correlate with success. It does not, for the simple reason that most agentic projects fail long before framework choice becomes the binding constraint.

Consider the numbers, drawn from the most credible recent sources rather than vendor decks.

Stanford HAI’s 2026 AI Index — a 400-plus-page audit with no product to sell — records something remarkable on raw capability. On OSWorld, a benchmark of real computer tasks across actual operating systems, the best agents jumped from roughly 12% task success in early 2024 to 66.3% by early 2026, within six percentage points of the human baseline. The tools, in other words, now work. And yet the same report finds that AI-agent deployment across business functions sits in the single digits almost everywhere, even as organisational AI adoption reaches 88%. Capability has crossed the threshold; deployment has not followed.

Why not? The MIT NANDA initiative’s GenAI Divide: State of AI in Business 2025 supplies the blunt answer: roughly 95% of enterprise generative-AI pilots deliver no measurable profit-and-loss impact. Not because the models are weak — MIT is explicit that model quality is not the culprit — but because of a “learning gap.” Tools that dazzle in a boardroom demo collapse in the field because they cannot retain context, adapt to a workflow, or improve over time. Budgets pile into high-visibility sales and marketing pilots while the real returns sit unglamorously in back-office automation. Most tellingly for anyone choosing how to build: pilots that paired internal specialists with external partners succeeded 67% of the time, against just 22% for internal IT-only builds. The determinant of success was integration discipline and partnership, not the library on the requirements file.

McKinsey’s work rhymes with this. Its research finds that nearly two-thirds of enterprises have experimented with agents, but fewer than one in ten has scaled them to tangible value in any given function — and eight in ten cite data limitations, not tooling, as the roadblock. McKinsey’s proposed answer, the “agentic mesh” — a composable, vendor-agnostic orchestration layer through which agents, tools, and systems coordinate under shared governance — is explicitly an architecture and governance concept, not a framework recommendation. Its companion notion of the “agentic organisation” rests on five pillars — business model, operating model, governance, workforce, and technology — of which the framework is a rounding error inside the fifth.

Put the three together and the picture is stark. The capability is real and improving fast. The deployment gap is enormous. And the failure modes cluster almost entirely around context, data, integration, and governance — not around whether you chose CrewAI or LangGraph. This is the empirical foundation of what I have elsewhere called the Frozen Workforce: capability abundant on the shelf, value locked in pilots, the thaw gated not by intelligence but by organisational readiness.

Part Four: The layer that actually matters is interoperability

If there is a genuinely consequential shift underway — one that will outlast every framework flame-war — it is the emergence of open interoperability protocols, and this is where a serious architect should be spending attention.

Two standards now form the connective tissue. Anthropic’s Model Context Protocol (MCP), introduced in late 2024, is the vertical standard: agent-to-tool. It turns the old N×M integration nightmare — every agent custom-wired to every data source — into a single standardised interface. The apt metaphor, which has stuck, is “USB-C for tools.” Google’s Agent2Agent (A2A) protocol, announced in April 2025, is the horizontal standard: agent-to-agent. It lets agents built by different vendors, on different frameworks, in different clouds, discover one another via published “Agent Cards,” delegate tasks, and coordinate — “HTTP for agent collaboration.”

What makes this more than a curiosity is the governance trajectory. Google handed A2A to the Linux Foundation in mid-2025; IBM’s Agent Communication Protocol was folded in; and by December 2025 the Foundation had established the Agentic AI Foundation as a neutral home hosting MCP, A2A, and related infrastructure together. A2A now counts more than 150 supporting organisations — AWS, Cisco, Google, IBM, Microsoft, Salesforce, SAP, ServiceNow — with production SDKs across five languages. Microsoft’s Agent Framework ships with both protocols native. This is the plumbing of an open agentic web being laid in real time, and it is vendor-neutral by design.

The strategic implication is the one I keep pressing on clients: bet on the protocols, not the frameworks. Frameworks are how you build a given agent this quarter; you will swap them. Protocols are how your agents will find, trust, and transact with other agents — including agents you do not own, inside partners and suppliers — for the next decade. An agentic system architected around open standards keeps its options open. One welded to a single vendor’s proprietary orchestration is accruing the most expensive kind of technical debt: the kind you cannot see until you try to move.

The protocols do not, I should stress, solve everything. The current specifications are strong on discovery and delegation and conspicuously thin on governance — on expressing who is accountable, what an agent is permitted to do, and how that is enforced across a boundary. That gap is precisely where the hard, unglamorous, and genuinely defensible work now sits. It is why I have spent so long arguing that governance must shift from a periodic, paper-heavy exercise to something real-time, data-driven, and embedded — with humans holding final accountability. Autonomy at scale is impossible without it; without governance you stay stuck in pilots, and with operationalised governance you earn the right to scale.

Part Five: So how should you actually choose?

Having spent four sections insisting the framework is not the point, let me be practical, because you still have to pick something. Here is the decision sequence I actually use, in order.

First, resist building an agent at all. Ask whether a single well-tooled model call, or a deterministic workflow, will pass your evaluation. Very often it will, at a fraction of the latency, cost, and failure surface. Reserve genuine agency — the model-directed loop — for problems where you cannot hardcode the path but can verify progress. This is the frontier-lab consensus, and it is consensus for a reason.

Second, match the pattern to the problem, not the brand. If the flow is predictable and sequential, you want a workflow, and a lightweight orchestration library will do. If it is open-ended and exploratory, you want an autonomous loop. If it needs specialised division of labour, you want role-based multi-agent — but only once a single agent has demonstrably failed. If you are merely validating an idea, reach for a rapid-prototyping canvas and throw it away afterwards.

Third, separate the three decisions Chase identified. Choose your authoring abstraction, your production runtime, and your harness as distinct questions. Do not let a framework that is pleasant to prototype in silently commit you to a runtime that cannot survive production, or vice versa. Many teams discover too late that the abstraction which accelerated the demo becomes the thing they must rip out to scale — a 50-to-80% rewrite is a real and common tax.

Fourth, architect for interoperability from day one. Adopt MCP for tools and design your agents to be A2A-addressable even if you do not need cross-vendor coordination yet. You are buying optionality against a future that is arriving faster than most roadmaps assume.

Fifth — and this is where the survivors actually differentiate — invest disproportionately in the things the framework does not give you: clean and governed data, tight and well-described tools, real evaluation harnesses, memory and feedback loops so the system learns, human-in-the-loop gates at the points of irreversible action, and observability so you can see what your agents are doing. This is the 5% that MIT found crosses the divide. It is unglamorous. It is also the whole game.

The turbulence and the abundance

The framework wars are loud precisely because they are the easy argument — a matter of taste and tribe, resolvable in a comment thread. The real work is quiet, cumulative, and organisational: context engineering, data foundations, governance that operates at the speed of autonomous systems, and the patient integration that turns a demo into a P&L line.

The frontier labs have converged on simplicity-first. The founders have moved on from the framework to the harness, the platform, and the protocol. The consultancies have located the bottleneck in organisational readiness, not tooling. And the most rigorous data we have shows capability racing ahead while deployment crawls behind — a gap measured not in model parameters but in institutional muscle.

That gap is the opportunity. The capability sits on the shelf, more able by the month, waiting for organisations disciplined enough to operationalise it. The framework you choose this quarter matters far less than whether you build the governance, the data foundations, and the standards-based architecture that let you scale when — not if — the thaw comes.

So by all means, close a few of those seventeen tabs. Then go and do the hard part. The framework was never the point.

Luke Soon writes on the human experience in the age of artificial intelligence at GenesisHumanExperience.com. He is the author of Genesis: Human Experience in the Age of Artificial Intelligence and Synthesis: SuperIntelligence Protocol.

Sources and further reading

Anthropic — Building Effective Agents and Effective Context Engineering for AI Agents (engineering blog)
Andrew Ng — Four agentic design patterns (The Batch / DeepLearning.AI); Agentic AI course, 2025
Harrison Chase / LangChain — How to Think About Agent Frameworks (April 2025); Agent Frameworks, Runtimes, and Harnesses (2025–26)
João Moura / CrewAI — public commentary, 2025; CrewAI Enterprise
OpenAI — A Practical Guide to Building Agents
Microsoft — Agent Framework (unifying AutoGen and Semantic Kernel), GA 2026
McKinsey — Seizing the Agentic AI Advantage (June 2025); The Agentic Organization (September 2025); Reimagining Tech Infrastructure for Agentic AI
MIT NANDA — The GenAI Divide: State of AI in Business 2025
Stanford HAI — 2026 AI Index Report
MCP (Anthropic), A2A (Google / Linux Foundation), and the Agentic AI Foundation
IBM Technology — Agentic AI Frameworks Explained (the video that started this conversation)