Claw Chronicles: The Coding Stack Nobody Designed

Something happened over the last two months that nobody planned. Claude Code, Cursor, and OpenAI Codex organically settled into distinct layers of a single composable stack. The New Stack wrote about it last month, and every practitioner I talk to confirms it: terminal-native Claude Code as the orchestration layer, Cursor for IDE-native editing, and Codex for sandboxed async work and review.

This wasn’t a standards play. It wasn’t a partnership announcement. Developers just started using them together, and the tools happened to have complementary architectures. Claude Code’s Unix philosophy (composable, terminal-first, no IDE lock-in) made it the natural controller. Cursor’s polished tab-completion-plus-agent-mode made it the natural editor. Codex’s sandboxed VM with async PR delivery made it the natural background worker. Each tool occupies a niche that the others don’t, and none tries to be everything.

The stack that ate the competition

The practical pattern most teams run: Claude Code orchestrates, fires off subtasks to Codex for long-running work, and the developer uses Cursor for interactive editing. MCP is the connective tissue. All three support MCP servers now (Claude Code natively, Cursor and Codex via config). Devin, Windsurf, and Copilot are still building their MCP layers.

The interesting question is whether this stack is stable or transitional. The DEV Community weekly makes the point that “this pattern is not stable. It will likely change again before the year is out.” I think they’re wrong. Not that the specific tools won’t change, but that the three-layer pattern (orchestration, execution, review) is the right architecture, and tools will continue to converge on it.

Google’s Antigravity 2.0 announcement at I/O last week is the strongest evidence. Antigravity isn’t trying to be another Cursor or Claude Code. It’s a platform: a desktop app, a Go CLI, an SDK, managed agents in the Gemini API, scheduled background tasks, and multi-agent orchestration. The pitch is explicitly about managing an agent team, not about being a better code editor. That’s the orchestration layer.

The difference from Claude Code’s approach: Antigravity is opinionated and integrated. Claude Code is composable and minimal. Antigravity gives you a Chromium browser, voice commands, and Firebase integration out of the box. Claude Code gives you a terminal, a text editor, and whatever MCP servers you can wire up. These are genuinely different philosophies, and there’s room for both.

What Codex got right

OpenAI’s Codex additions this month deserve more attention than they’re getting. Persisted /goal workflows that survive across sessions. Multi-day automations that can run for hours without supervision. A sandboxed VM that maintains state between invocations.

Multi-day execution is the feature that pushes Codex into new territory. Previous coding agents operated within a single session. You gave them a task, they worked on it, they stopped. Codex can now schedule future work for itself, wake up automatically, and continue across days. This is persistent autonomous coding, not just assisted coding.

The safety model matters here. Codex runs in a sandboxed VM with scoped file access, deny-read rules, and firewall policies. “Full access” mode exists but requires explicit opt-in. This is the right default for autonomous multi-day execution: locked down by default, opened up deliberately. The alternative (full access by default, like some competitors) is a security incident waiting to happen.

Protocol convergence

While the tools were stacking up organically, the protocols underneath were converging deliberately. MCP hit 97 million monthly SDK downloads by March 2026, comparable scale to React npm packages achieved in 16 months instead of three years. Every major AI provider supports MCP natively now.

A2A (Agent-to-Agent) hit v1.0 stable this year under the Linux Foundation. The two-layer architecture (MCP for tool access, A2A for agent coordination) is crystallizing as the reference model. The Q2 interoperability specification is supposed to make MCP and A2A work together natively. If that lands, the “composable stack” pattern gets a formal foundation instead of just developer convention.

The enterprise pain here is real. A typical mid-size company in 2026 runs Salesforce Agentforce (A2A native), Microsoft Copilot Studio (MCP plus proprietary), Google Vertex AI Agent (A2A native), and internal custom agents. Four agent platforms, two protocols, zero interoperability. The MCP+A2A convergence is the only credible path out of that mess.

The prediction

The “one tool to rule them all” era is ending before it properly began. The tools that win will be the ones that accept being one layer in a stack rather than trying to be the entire stack. Claude Code understood this from the start. Cursor is figuring it out. Google is betting on it with Antigravity. OpenAI is hedging with Codex (both a standalone tool and a composable component).

The next fight isn’t about which coding agent is best. It’s about who owns the orchestration layer. Claude Code owns it in terminal-native workflows. Antigravity wants it in the IDE/platform. Codex’s automations suggest OpenAI sees it as a cloud service. Three different answers to the same question, and they might all be right for different users.

The thing I keep coming back to: this composable stack emerged without anyone designing it. Nobody at Anthropic, OpenAI, or Google sat down and said “you handle orchestration, you handle editing, you handle review.” Developers just found the combination that worked. That’s how you know an architecture is right. It doesn’t need a committee.