The Agent Framework Gold Rush Looks Exactly Like the JS Framework Wars. Most of It Will Be Dead in 18 Months.

There is a Reddit thread making the rounds that compares agent frameworks. It covers more than twenty of them. LangChain, LangGraph, LlamaIndex, Haystack, Semantic Kernel, Pydantic AI, DSPy, Mastra, AutoGen, CrewAI, MetaGPT, the OpenAI Agents SDK, Google ADK, Strands Agents, CAMEL, AutoGPT, AgentScope, DeerFlow, and the list keeps scrolling. Every vendor on that list has also published a 'best agent frameworks 2026' listicle, and in every single one, guess who ranks first. If you have been in this industry longer than one hype cycle, this smells like something. It smells like JavaScript in 2013.

I am going to make a prediction and I am not going to hedge it. Most of those twenty-plus frameworks will be dead or absorbed by early 2028. Not struggling. Dead. And the pattern that kills them is already visible if you know which movie you are watching.

The consolidation has already started

You do not have to wait for my prediction to see the bodies. Microsoft merged Semantic Kernel and AutoGen into a unified Microsoft Agent Framework, 1.0 GA on April 3, 2026, deprecating two entire ecosystems in one press release. AutoGen, which two years ago was the hottest multi-agent project on GitHub, is now politely described as 'legacy for research-style conversations.' That is the kind of phrase you put on a tombstone. The OpenAI Agents SDK passed AutoGen on production deployments by early 2026. LangGraph hit 1.0 GA in October 2025 after LangChain spent a year living down its own abstraction soup. The Claude Agent SDK got renamed and reworked. CrewAI now ships pluggable backends, which is what you do when you are not sure which layer of yourself will survive. Version churn is constant and breaking. If you built on any of these eighteen months ago, you have already rewritten something.

We have watched this exact movie before

Around 2011, the JavaScript world exploded with client-side frameworks. Backbone, Knockout, and Ember all grew fast and peaked around 2013. Then Angular 1 won, and all three declined in lockstep, not because they got worse but because the ecosystem consolidated around a default. Then Google shipped Angular 2 as a ground-up rewrite, infuriated its own community, killed its own momentum, and held the door open for React. Backbone and Sencha did not just fade, they died leaving corpses, mountains of legacy code that somebody in an enterprise somewhere is still maintaining today, a decade later, on a salary that could have gone to building something new.

That is the full pattern, told properly. Explosive proliferation. Brutal consolidation. One or two survivors. And a decade of legacy maintenance for everyone who bet wrong. The proliferation phase feels like abundance. It is actually the setup for the cull.

Why agent frameworks get the same ending

Three forces make this rerun inevitable. Start with the barrier to entry, which is roughly zero. An agent framework is a few thousand lines of orchestration glue around a model API. A loop, some state, a retry policy, a tool-calling convention. That is why everyone ships one. When everyone can build the product, the product is not the moat.

Second, the platform underneath is moving. Model APIs change quarterly. Frameworks either break, chase, or get absorbed upstream. And the labs keep shipping their own SDKs, which is the Angular 2 move performed against the independents instead of against themselves. Why would OpenAI or Anthropic let a middleware layer own the developer relationship when they can bundle one for free?

Third, the differentiation is thin. Strip the branding off most of these frameworks and you find loops, state machines, and tool-calling conventions with different vocabulary. When abstractions are that thin, the winner is not decided by elegance. It is decided by distribution and defaults. That favors the platform owners, OpenAI, Anthropic, Microsoft, Google, and at most one independent. Right now LangGraph holds the position React held, big ecosystem, observability tooling, real enterprise deployments. Everyone else is Knockout waiting for the graph to bend down.

The 18-month scoreboard

Here is what early 2028 looks like. The platform SDKs survive, because bundled distribution always survives. One or two independents with genuine ecosystems survive, LangGraph is the obvious candidate. And a huge share of production agents run on no framework at all, just code hitting an API. That last group is the vanilla-JS contingent of this era, the people who watched the wars from the sidelines, wrote plain functions, and quietly won a lot of the web while everyone else migrated build systems.

Which brings up the wry part. The jQuery of agents has not shipped yet. In the JS wars, the thing that outlived nearly everything was not a grand framework, it was the boring utility everyone actually used. There is a decent chance the durable winner of the agent era is not a framework at all but a protocol, tool calling plus MCP, wrapped in plain code you own.

What you should actually do about it

If you are building a company right now, treat framework choice as a two-way door. Wrap whatever you pick behind your own thin interface, so that when it dies, and the base rates say it will, you pay for a refactor instead of a rewrite. The teams still maintaining Backbone apps in 2026 did not make a technology mistake, they made an architecture mistake. They let the framework touch everything.

Put your real bets on the layers that hold value. The layer below, your models, your data, your evals. The layer above, your workflow and your UX. Not the middle. The middle is where the war is, and wars are bad neighborhoods for capital.

If you genuinely must pick a framework, pick boring. The one with the biggest production footprint and the best observability story, or no framework at all. Nobody ever got fired for writing a function.

And whatever you do, do not build your company as a framework unless you have a distribution advantage the platforms cannot copy. Selling picks in a gold rush is great advice until you notice the mine owners are handing out free picks at the entrance.

Gold rushes reward two groups, the miners who strike early and the people selling durable tools. Framework authors are neither. They are selling maps that redraw themselves every quarter. Build your product, wrap your dependencies, and let the framework wars bury their own dead.