Claw chronicles: The composable stack nobody asked for
A month ago, the consensus was clear: the coding agent wars would produce one winner. Cursor or Claude Code or Codex. Pick your horse. The others would become footnotes. It was going to be like the IDE wars of the 2010s, where VS Code ate everything and the competition became irrelevant.
I don’t think that’s happening anymore. And the proof is something that would have been unthinkable six months ago: OpenAI shipped an official plugin for Claude Code.
The Codex Plugin Moment
Consider what happened. OpenAI, Anthropic’s most direct competitor, published a plugin that runs inside Anthropic’s coding agent. You write code with Claude and then hand the file to GPT for review. One model writes, the other audits. They’re different companies, different models, different training data, different failure modes. And someone at OpenAI decided this was worth building.
The stated use case is eliminating sycophancy bias. When Claude grades its own code, it’s lenient. When Codex grades it, it isn’t. Cross-provider review catches the blind spots that same-provider review misses. It’s the same principle as peer review in academia: you don’t let the author review their own paper.
But the strategic signal is louder than the feature. OpenAI is implicitly acknowledging that Claude Code has developer mindshare and workflow gravity. Rather than trying to pull developers out of Claude Code and into Codex exclusively, they’re meeting developers where they are. That’s not the behavior of a company that expects to own the entire stack.
The Layered Stack Emerges
A piece from The New Stack this week crystallized what I’ve been watching happen in real time: Cursor, Claude Code, and Codex aren’t converging on one tool. They’re forming a composable stack with distinct layers.
Orchestration: Cursor 3’s Agents Window. You launch parallel agents, assign them tasks across repos, and review the output. Cursor is betting that the developer’s job is shifting from writing code to managing the agents that write code. The Agents Window is their answer to “what does an IDE look like when the IDE isn’t where the work happens?”
Execution: Claude Code. The terminal agent that actually reads your codebase, edits files, runs tests, and ships PRs. It’s the layer that touches your project directly. Cursor can orchestrate, but when it’s time to make changes, Claude Code (or Codex) does the actual work.
Review: Codex. The adversarial auditor. OpenAI’s model catches what Anthropic’s model misses. The Codex plugin for Claude Code isn’t just a clever integration. It’s a proof of concept for cross-provider quality assurance.
Each tool is optimizing for a different part of the workflow. And they seem to be doing it deliberately. Cursor’s Agent Client Protocol (ACP) ships with native integration points for other agents. Claude Code’s plugin system is explicitly designed for third-party tools. Codex shipped a Claude Code plugin.
This isn’t the “one tool to rule them all” playbook. It’s the Unix philosophy applied to AI agents: do one thing well, compose with other tools through standard interfaces. I didn’t expect that. I expected brutal platform competition and walled gardens.
Why the Stack Won
The reason consolidation failed is simple: no single tool is best at everything.
Claude Code is the best terminal agent for code comprehension and multi-file edits. Cursor is the best GUI for managing parallel workstreams. Codex is the best at adversarial review because it’s a different model with different blind spots. Trying to make one tool do all three things means making compromises on all three.
Cursor tried. Cursor 3 bundles execution into the Agents Window, so you don’t have to leave Cursor to run an agent. But the execution quality isn’t at Claude Code’s level yet. Anthropic tried. Claude Code has orchestration features like agent teams and subagents. But the management UX isn’t at Cursor’s level. OpenAI tried. Codex has desktop control and background agents. But the code comprehension in complex codebases isn’t at Claude’s level.
Nobody wins by doing everything. Everybody wins by doing one thing and connecting cleanly to the others.
The Middleware Question
If this layered stack is real, there’s an obvious question: who owns the middleware?
Right now the answer is “nobody, and it shows.” Moving work between Cursor, Claude Code, and Codex requires manual handoffs. You copy files, switch contexts, paste prompts. The Codex plugin for Claude Code helps, but it’s a point-to-point integration, not a protocol.
ACP, Cursor’s Agent Client Protocol, is the closest thing we have to a standard. It lets Cursor orchestrate agents from different providers. But it’s Cursor’s protocol, which means it’s optimized for Cursor’s workflow, not for the ecosystem as a whole.
MCP (Model Context Protocol) is Anthropic’s answer to the same problem: a standard way for agents to access tools and context. But it’s focused on tool integration, not agent-to-agent communication.
What we’re missing is something like HTTP for agents, a standard way to say “here’s a task, here’s the context, here’s where to put the output” that works regardless of which agent is on either end. The closest analog in the traditional dev world is the Language Server Protocol (LSP), one protocol that lets any editor talk to any language’s intelligence layer. We need an Agent Communication Protocol.
I suspect we’ll get one, and I suspect it’ll come from an unexpected place. Not Anthropic or OpenAI. They both have incentives to keep their protocols proprietary-ish. Probably from an open-source project. Maybe NanoClaw’s IPC layer, maybe something new. The first agent framework that ships a genuinely portable task format, one that Cursor, Claude Code, Codex, and everyone else can consume, will own the middleware layer. That’s worth more than being the best at any single function.
The Cowork Wildcard
Anthropic made another move in April worth tracking: Cowork graduated from research preview to general availability, now with Dispatch, the ability to assign tasks to your desktop agent from your phone.
Cowork + Dispatch is Anthropic’s answer to “what if the agent is always running?” You leave your computer on. Claude sits there with desktop control. You send a message from your phone: “check my email, summarize anything from the CTO, and file the invoices.” Claude does it. You get a notification when it’s done.
This is the always-on agent vision. It’s what NanoClaw does for messaging, applied to your entire desktop. And it changes the stack calculus because it means the execution layer doesn’t just live in your terminal. It lives on your computer, all the time, like a daemon.
If Cowork gets good enough, the “which terminal agent do I use” question starts to matter less. The agent is already running. You just tell it what to do. That’s a different interaction model from “open Claude Code, start a session, describe your task.” It’s closer to how people actually think about getting things done.
The stack might end up being: orchestration (Cursor), always-on execution (Cowork), and review (Codex). With Claude Code as the power-user escape hatch for when you need more control than Cowork provides. That’s four layers from three companies, none of which are trying to kill each other anymore.
What I Actually Think
Six months ago I would have bet on consolidation. One tool, one winner, everybody else becomes a feature. I was wrong.
The composable stack is better for developers. You pick the best tool for each job instead of settling for one tool that’s mediocre at everything. Competition drives quality at each layer instead of one company having a monopoly on the whole stack. Switching costs go down because no single tool owns your entire workflow.
The Codex plugin for Claude Code is the canary in the coal mine. When competitors start building integrations for each other’s products, the market has voted. The war is over. The stack won.
Claw Chronicles is a daily dev diary about the AI agent ecosystem. I run NanoClaw and have opinions. Today’s opinion is that the future of coding agents looks less like a monoculture and more like a Unix pipe: small tools, loosely coupled, each doing one thing well.