If you were waiting for the coding-agent market to crown a winner before you committed, stop waiting — it isn't going to happen, and it already resolved a different way. In 2026 the category didn't consolidate to one tool. It converged into an interoperating stack, and the sharpest single piece of evidence is that OpenAI now ships an official plugin — codex-plugin-cc, Apache-2.0 licensed, at v1.0.6 as of July 8, 2026 — that runs Codex inside Anthropic's Claude Code. Two labs that compete on frontier models shipped an integration so you can write code with one and have the other review it, without leaving your terminal. That is not a truce. It's the market telling you the unit of decision changed. The question is no longer which coding agent do I buy but what do I standardize on so I'm never locked into one.
What actually changed#
The plugin is the tell, not the whole story. Installed into Claude Code, it adds slash commands like /codex:review, /codex:adversarial-review, /codex:rescue, and /codex:transfer — you can delegate a task to Codex, hand off a persistent thread, or run a cross-provider review loop that's harder to fool with a single model's blind spots. Codex here isn't a competitor you switch to; it's a capability you mount inside the agent you already drive.
Underneath that, an open standard is doing the plumbing. The Agent Client Protocol (ACP) is a JSON-RPC standard — introduced by Zed, backed by JetBrains — that standardizes how an editor talks to an agent, the editor-to-agent counterpart to MCP's agent-to-tools. ACP is to editors and agents what LSP was to editors and languages: it collapses an M×N mess of bespoke integrations into M+N. Teach one editor ACP and it inherits every ACP agent; ship one ACP agent and every ACP editor can drive it. That's the connective tissue letting a stack exist at all.
And builders are already living in that stack. Running 2–3 agents in parallel on the same repo is now routine, isolated with git worktrees so parallel edits never collide. Claude Code supports this natively — a --worktree flag and per-subagent isolation — and tools like the open-source parallel-code dispatch Claude Code, Codex, and Gemini side by side, each in its own worktree. The mental model shifted from "my coding assistant" to "my bench of agents."
Why "which one" is the wrong question#
Pick a single tool and you've made a bet that has to keep paying off every quarter against labs shipping monthly. Standardize on the stack and you've made a bet on layers you control. The difference matters because the agents themselves are converging on the same primitives:
- Cursor is model-agnostic by design — its model picker offers frontier models from OpenAI, Anthropic, and Google alongside its own, billed at published API rates. The editor is the constant; the model is a dropdown.
- Codex runs standalone as a CLI, in the cloud, and as an IDE extension — and as that plugin inside Claude Code.
- Claude Code is itself a plugin host with an ACP adapter, so it both drives and gets driven.
- Google's Antigravity leans into multi-agent orchestration as a first-class idea rather than a single assistant, per Google's own I/O 2026 developer highlights.
When every serious contender is either model-agnostic, mountable inside another, or built to orchestrate several agents, "which one" is a category error. The tools stopped being mutually exclusive. Your standardization decision is what survives when you swap any one of them out next quarter.
What to standardize on#
Here's the founder-practical version. Standardize on the neutral layers you own, and treat every agent as a swappable model endpoint sitting on top of them:
- Git worktrees as the isolation boundary. This is your concurrency and safety layer, and it's vendor-neutral by definition — it's just git. Whether you run one agent or four, worktrees are how parallel work doesn't corrupt parallel work. Any agent worth using either speaks worktrees or gets wrapped by something that does.
- MCP for tools, ACP for editors. Keep your capabilities (databases, browsers, internal APIs) behind MCP servers and your editor integration on ACP where you can. Both are open; both mean the tool and editor surfaces outlive any single agent. We've covered why ACP and MCP compose rather than compete — that composition is exactly what makes an agent replaceable.
- Plain-text agent config in the repo. Prompts, subagent definitions, review rules, and skill files should live as version-controlled text next to your code, not locked in a vendor's cloud console. That's what makes migrating agents a diff instead of a rewrite. The unbundling trend is real: LangChain's Deep Agents split the harness, the coding agent, and the ACP adapter into separate packages precisely so the model, the loop, and the editor are three independent choices.
- A cross-provider review loop. Use one lab's model to write and a different lab's to review. The Codex plugin makes this a slash command inside Claude Code today; the point is architectural, not brand-specific — a second, differently-trained reviewer catches what a model won't flag about its own output.
The cost angle follows from the same logic. If your agents are endpoints, you route by price-performance per task: a cheap fast model for boilerplate and a frontier model for the gnarly refactor, without re-tooling. Lock into one platform's bundled model and you lose that lever entirely.
The recommendation#
Standardize on one primary driver, an open interop layer, and a rival reviewer — and keep all three swappable. Concretely: make a terminal-native agent that hosts plugins and speaks ACP your default cockpit (Claude Code fits today); put your tools behind MCP and prefer ACP-capable editors so you're never re-integrating; isolate every parallel run in a git worktree; and wire in a second-provider reviewer — the official Codex plugin is the lowest-friction way to do that right now. Keep every prompt and agent definition as text in your repo.
Do that and no single vendor's roadmap can strand you. When a better model ships next month — and it will — you change an endpoint, not your entire workflow. This is the same lesson the tools taught themselves recently, when they spent a release cycle shipping guardrails instead of horsepower: the durable value isn't the frontier, it's the scaffolding around it. Build the scaffolding. Rent the frontier.
