Four terminal-native coding agents now compete for the same desk: xAI Grok Build (launched May 15), Anthropic Claude Code (the agent that ported Bun to Rust in nine days), OpenAI Codex CLI, and Cursor Composer 2.5 (released May 18). They all sit in the same terminal slot but the trade-offs are not subtle. The short verdict: Claude Code is the safest default for paying solo developers, Composer 2.5 wins on price-per-task, Grok Build wins on context size and parallelism if your wallet allows it, and Codex CLI is the open-source escape hatch for anyone who wants to swap the backend model.
This comparison is based on the four launches as shipped between May 14 and May 18, the public technical reports for each (Composer 2.5's Composer 2 paper still applies, plus xAI's launch material via basenor's reporting), pricing as listed at launch, and the public benchmarks each team chose to publish. Where vendors disagree on a metric, the comparison defers to Artificial Analysis or SWE-bench Multilingual when those are the cited references.
Quick Picks
Pick Claude Code if you already pay for Claude Pro or Max, work mostly inside a single project at a time, and want the agent with the most production-track-record this quarter. The Bun rewrite shipped on Claude Code, the Anthropic limits doubled in May, and the model rotation includes Opus 4.7 for hard tasks.
Pick Cursor Composer 2.5 if you care about price-per-line, run agentic tasks against the same codebase day after day, and want the model trained specifically to behave well on long-horizon edits. At $0.50 per million input tokens on the standard tier it is the cheapest fast-tier coding model in this group by a wide margin, and Cursor is doubling usage allowances for the first week.
Pick Grok Build if you run a large monorepo, need to load the whole thing into context at once, and have a team budget that can absorb $300 per month per seat. The 2-million-token context and 16-agent Heavy dispatch are differentiators no other product in this group matches today.
Pick Codex CLI if you want a fully open-source agent loop you can fork, swap models inside, or run against a self-hosted backend. The repo is on github.com/openai/codex and ships under an MIT-style license, with first-class support for the OpenAI API but a clean abstraction over any chat-completions backend.
Detailed Comparison
The table summarizes the four agents on the dimensions that matter for daily use. Each row is sourced from the launch documentation or the linked third-party coverage; nothing here is extrapolated from benchmarks the vendor did not publish.
| Dimension | Grok Build | Claude Code | Codex CLI | Composer 2.5 |
|---|---|---|---|---|
| Entry price | $99/mo intro ($300/mo SuperGrok Heavy) | Claude Pro $20/mo, Max $100/mo, $200/mo | API metered (gpt-5 family) | $20/mo Cursor + $0.50 / $2.50 per M tokens |
| Context window | 2,000,000 tokens (Grok 4.3 beta) | 200,000 tokens (Claude Opus 4.7, Sonnet 4.6) | Up to model maximum (gpt-5: 400K) | Native long-horizon (Composer 2.5) |
| Parallel subagents | 16-agent Heavy dispatch | Serial subagents (configurable) | Single task in default config | Agent + background, not native fanout |
| Plan-before-execute | Plan Mode default, step approval | Plan via slash command, approval workflow | Plan via prompt, no enforced gate | Agent prompts a plan, edit-then-run |
| Best public benchmark | Grok 4.3 leaderboard placement (Artificial Analysis) | Opus 4.7 SWE-bench Verified pass-at-1 | gpt-5 Codex evals (varies by model) | 73.7 SWE-bench Multilingual (Composer 2) |
| Platforms | macOS, Linux (Windows beta) | macOS, Linux, Windows | macOS, Linux, Windows | macOS, Linux, Windows (Cursor app) |
| License | Closed beta | Closed | Open source (MIT-style) | Closed |
Plan Mode, Approval, and How the Agent Talks Back
Every product in this group treats Plan Mode as the default workflow now, but the implementations differ. Grok Build's Plan Mode is the strictest: nothing executes until each step in the proposed plan is approved or rewritten. Claude Code's plan slash command produces a similar artifact but the approval gate is configurable, which suits experienced users who want the agent to roll through low-risk steps without prompting. Codex CLI does not enforce a gate by default but the open-source codebase makes it trivial to wrap one. Cursor's Composer 2.5 still surfaces a plan through the chat sidebar rather than a dedicated mode, which is fine for in-editor use but feels less terminal-native than the others.
Parallelism Versus Context
The single biggest architectural split is parallel subagents versus large context. Grok Build's 16-agent Heavy dispatch lets the system fan out across files or tests at the same time, which is the right shape for wide refactors and large-test-suite migrations. Claude Code's serial subagent model trades that throughput for predictability and a smaller surface area for race conditions; Claude Code's agent view already supports parallel sessions across separate panes for users who want the pattern. Composer 2.5's path is different again: rather than fan out, Cursor invested in long-horizon behavior inside a single agent, which is exactly the failure mode most coding agents hit on hour three of a refactor. Pick fanout if your task is wide. Pick a long-horizon model if your task is deep.
Model Rotation and Backend Swap
Three of the four products lock you to the vendor's models. Codex CLI is the exception: because it is open source, the backend chat-completions client can be repointed at any compatible endpoint, including the same gpt-5 family Codex was designed for, an open-weights model running on a self-hosted server, or the local model wrappers that surfaced after Anthropic doubled Claude Code limits reset the cost calculus in May. For teams that need an exit strategy, that is the single biggest differentiator in this whole comparison, and it costs nothing if you already pay for an API key.
Where the Benchmarks Actually Disagree
Composer 2.5 inherits a 73.7 score on SWE-bench Multilingual from Composer 2, the best public number any vendor in this group is currently citing. Grok Build does not yet publish a SWE-bench number; its launch material leans on Grok 4.3's Artificial Analysis placement instead. Claude Code does not publish a CLI-specific benchmark either, but Opus 4.7 has the highest SWE-bench Verified pass-at-1 of the models in this group. Codex CLI inherits whatever the backing model scores. The benchmarks are not directly comparable across products and none of them measure what most users actually care about, which is whether the agent stays useful on the third hour of a real task. That is the reason Cursor explicitly trained Composer 2.5 for long-horizon behavior; it is also why Grok Build leans on Plan Mode review rather than benchmarks in its launch coverage.
When Each One Wins
Grok Build wins for teams doing wide, parallelizable work on large monorepos. The 2-million-token context plus 16-agent dispatch is the right shape for migrations that touch hundreds of files, test-suite rewrites that benefit from parallel runs, and architectural refactors where the agent needs the whole map at once. The price tag presumes a team that already treats an agent seat as a line item.
Claude Code wins for solo developers and small teams who already pay for Claude. The flagship proof point this month is the Bun rewrite: 1,009,257 lines of Rust shipped in nine days by Claude Code on a real production runtime. That is the strongest single case study any of these products has, and it lands inside a $20-to-$200-per-month subscription tier rather than a $300 enterprise SKU.
Cursor Composer 2.5 wins for cost-conscious agentic work and any team that already lives inside Cursor. The $0.50 per million input tokens standard tier is roughly an order of magnitude below the fast-tier prices everyone else publishes, the long-horizon training is specifically aimed at the failure mode most users hit, and the first-week double-usage perk on the May 18 release is a free benchmarking window for any existing Cursor subscriber.
Codex CLI wins for engineers who refuse to be locked in. The fact that the entire agent loop is on GitHub means you can swap models, audit the prompts, run it against a self-hosted backend, or fork it into a team-internal product. That is also why Codex CLI is the right reference implementation to study when comparing how the others orchestrate planning, tool use, and review.
Pricing and ROI
Reduce the four products to a per-developer-month cost and the rank order flips depending on usage shape. Cursor Composer 2.5 on the standard tier costs roughly $20 plus token usage, which on a typical refactor week (3 to 5 million input tokens) lands around $25 to $30 all-in. Claude Code on Claude Pro is $20 with usage caps that, after the May limits doubling, cover most solo workloads; Max at $100 or $200 covers serious agent-driven coding without spillover. Grok Build's $99 introductory rate is competitive for the first six months but the post-intro $300 per month is a tier of its own. Codex CLI is metered against the OpenAI API, so the bill scales with tokens; a moderate week against gpt-5 typically lands between $40 and $80 depending on context.
For a team of five engineers running an agent eight hours a day on a real codebase, Cursor or Claude Code are the lowest-risk picks. For a team of five doing weekly two-day refactor sprints against a 500K-line monorepo, Grok Build's wide context and parallel dispatch may earn its price back by collapsing the sprint into a single day. For a one-person shop that wants leverage without subscription overhead, Codex CLI plus a metered API key is still the cheapest entry into agentic coding in 2026.
Verdict
There is no single winner. The right pick depends on the shape of your codebase, your team size, and whether your work is parallel-wide or long-and-deep. Default to Claude Code if you already pay Anthropic and most of your work is single-project, deep-horizon refactors. Switch to Cursor Composer 2.5 if you want the cheapest fast-tier model trained explicitly for long-horizon behavior, and you are willing to live inside the Cursor editor. Upgrade to Grok Build if you are running a real monorepo, your team can absorb $300 per seat, and your work benefits from parallel subagents and a 2-million-token window. Keep Codex CLI in your back pocket regardless, because the open-source agent loop is the cleanest reference implementation in this group and it is the cheapest way to experiment with swapping backends.
FAQ
Is Grok Build actually worth $300 per month?
Only if your work pattern needs the 2-million-token context or the 16-agent parallel dispatch. For most solo developers the same money buys two months of Claude Max plus a year of Cursor, both of which cover the common cases. For a team running daily refactors against a half-million-line monorepo, the answer changes: Grok Build can collapse a multi-day sprint into a single session, and at that scale $300 per seat compares favorably to the engineer-hours it saves.
Does Cursor Composer 2.5 work outside the Cursor editor?
No. Composer 2.5 is a Cursor-only model and the long-horizon training is wired into Cursor's agent runtime. If you want the model itself, the only access is through a Cursor subscription. The first-week double-usage perk applies to all subscription tiers, so the cheapest evaluation path is a $20 Cursor month with the standard token tier enabled.
Can Claude Code match Grok Build's parallelism?
Partially. Claude Code's subagent model is serial inside one session, but multiple agent views can run in parallel across separate panes, which gets you most of the way to fanout for tasks where the subgoals are independent. The 2-million-token context is the harder gap to close: Claude's 200,000-token window forces chunking on large monorepos that Grok Build can load whole.
Why would anyone pick Codex CLI over the others?
Because it is the only product in this group you can fork. Teams that need to audit the agent loop, swap to a self-hosted model, or build internal tooling on top of the agent prompts have no equivalent in Grok Build, Claude Code, or Cursor. Codex CLI is also the cheapest way to run an agent on an existing OpenAI API key without a new subscription line.
Which one is closest to the Bun-style production rewrite workflow?
Claude Code, by direct evidence. The 1,009,257-line Bun rewrite shipped on Claude Code over nine days, which is the largest production port any of these agents has publicly delivered. Grok Build's parallel dispatch is plausibly suited to similar work but no comparable case study exists yet. Cursor's long-horizon training targets the same failure mode but Composer 2.5 is two days old at the time of writing. Codex CLI works for similar tasks if the backing model is strong enough.
