Twelve years ago the JavaScript world fought a war over frameworks. The lesson took years to learn: the framework that did the least won. React beat the batteries-included contenders, and a layer grew on top to supply everything React left out. That layer was the meta framework. The same fight is starting over AI agents, and it will end the same way. The winning agents will be narrow, and a new layer will grow above them. Call it the meta harness.

Lessons from the "framework wars"

Some readers are too young to remember the framework wars. It is worth looking back, because the shape of that fight maps onto where agents are now.

Start with jQuery. It took advantage of new browser capabilities and made one narrow job painless: manipulating the DOM and handling AJAX across browsers that all behaved differently.

Then, in the early 2010s, a wave of frameworks tried to level those primitives up. AngularJS, Knockout.js, and Backbone.js arrived. Instead of manipulating the DOM, you thought about building UI. Developers took the choice of framework very seriously. Unless you developed at the time, you cannot appreciate how heated the disagreements were. And like today, every other week a new framework appeared and added to the drama.

This changed in 2013 with React. It was not obvious then that it would dominate the way it does now. It shipped with licensing controversies and other issues. But the most important thing about React was that it did less. Where Angular reached for application-level concerns and tried to be batteries-included, React did one thing well. Angular and Vue still exist and still succeed. But React won.

The victory was not clear at the time. I was not a mere observer of the framework wars. I was in the middle of it, on the Angular core team.

I met the React team early and thought about how much React lacked. Building apps in React was hard. SEO was not handled. Routing and state management were painful. It was not fast.

But I was wrong, and spent a long time working out why.

React's deliberate minimalism is why it won. It did not try to do everything. It did the part the team had real expertise in. The React team at Meta knew how to build a rendering engine. They did not know how organizations outside Meta built applications, and did not pretend to. It is a mistake to assume one team understands the entire software development lifecycle across the industry. No team does.

Eventually the answer to React's shortcomings arrived: Next.js. Released in October 2016, it offered server-side rendering, static site generation, and API routes out of the box. It supplied what React lacked, primarily speed and SEO, on a simple principle: things should work with no setup.

Next.js was the first meta framework. Many others have emulated it since.

JavaScript frameworks appeared only because new capabilities arrived in the browser. Agents are here for the same reason: LLMs became capable enough to make large decisions on their own. The raw capability had to clear a bar before any tooling on top could work.

The players line up in a similar way. Some arrived first and kept expanding their surface area. Claude Code is the Angular of this era: reaching for more. Others stay focused on the core. Codex is closer to React. Some are open and not backed by a tech giant, like OpenCode and Pi. There is a lot of activity.

During the framework wars, everyone obsessed over benchmarks. But performance was not what limited your ability to ship applications. The same is largely true today. The model is no longer what limits you. Most people cannot tell Opus from GPT on a real task. The difference they feel comes from the agent harness, not the model underneath.

The stuff around the model begins to matter more. And the further we go, the more it will matter.

Minimalism will win again, for the same reason it won before. The teams building these agents cannot know how the rest of the world builds software, because everyone builds it differently. The broader a product reaches, the worse it fits both the startups and the banks. The tighter it holds to the core, the likelier it ships something that is actually the best.

Which brings me to the last point.

The industry has not realized it yet, but we need meta harnesses, just like we did not know we needed Next.js until we had it.

Right now we assemble them by hand, one ad-hoc tool at a time:

• Manage worktrees and clones.
• Manage skills.
• Wire up MCP servers to reach issue trackers and wikis.
• Make agents remember what they did.
• Make sessions collaborative.
• Connect to CI.
• Coordinate multiple agents.
• Enforce best practices, guardrails, and permissions.
• Open and track pull requests at scale.
• Feed context from one session into the next.

This is the same picture we had ten years ago, with a dozen competing implementations for state, routing, and bundling. The gaps in our workflows are real, and everyone patches them ad-hoc.

Every organization I talk to sees a gap between what the agent does and what the organization needs. Many, including large tech companies, are building internal meta harnesses to close it, not unlike the custom frameworks built on React years ago.

A meta harness is the layer that sits above one or more agent harnesses and supplies the operational scaffolding they lack: cross-repo reach, persistent memory, multi-agent coordination, and more. It does not touch the model or the agent loop. It wraps the agent the way Next.js wraps React.

Summary

Everything moves faster now and the stakes are higher. But the forces are the same ones that played out years ago. Every organization is building this layer in private right now. Soon more general solutions will emerge, as they always do.