xAI Drops Cursor's Composer 2.5 Into Grok Build at 30x Lower Cost

Grok Build just got a significant new model option. xAI has added Composer 2.5 , Cursor's in-house agentic coding model , to its terminal-based coding agent, making it selectable from the /models menu. The move is a direct result of the deepening compute partnership between Cursor and xAI's parent entity SpaceXAI, and it puts one of the most cost-efficient frontier-level coding models directly inside xAI's own developer toolchain.

Two companies, one model

To understand why this matters, you need to know who built what. Cursor shipped Composer 2.5 on May 18, roughly two months after Composer 2. xAI then integrated it into Grok Build on June 1 , just three days after Grok Build 0.1 hit public API beta. The model itself is Cursor's work; the deployment inside Grok Build is xAI's announcement.

The backstory is a compute partnership. Cursor partnered with SpaceX to accelerate its model training efforts, explaining that it had been bottlenecked by compute and would leverage xAI's Colossus infrastructure to dramatically scale up model intelligence. Composer 2.5 itself is built on the same open-source checkpoint as Composer 2 , Moonshot's Kimi K2.5 , while together with SpaceXAI, Cursor is training a significantly larger model from scratch using 10x more total compute, with Colossus 2's million H100-equivalents. That next model is Composer 3, not 2.5 , Composer 2.5 was trained on Cursor's existing RL pipeline before the Colossus infrastructure came online.

What Composer 2.5 actually is

Composer 2.5 is an agentic coding model with particular strengths in coding, agents, JSON, and tool use , including function calling, tool use, and code execution. The architecture is a Mixture-of-Experts (MoE) design , a model structure where only a small subset of the total parameters are activated for any given input, keeping inference fast while the overall model capacity stays large. Built on a MoE architecture derived from Kimi K2.5, the design activates only 32 billion of its 1 trillion total parameters per input token, keeping inference latency low even as overall model capacity remains enormous.

The headline training change is scale. It was trained on 25 times more synthetic tasks than its predecessor, Composer 2, with 85 percent of the compute budget going toward extra training and reinforcement learning. That ratio , 85% of compute on post-training , is the architectural statement: Cursor isn't shipping a thin wrapper on Kimi K2.5, it's doing the heavy lifting itself.

How they trained it to stay on track

The core training problem for long agentic sessions is credit assignment , figuring out which decision in a 100-step chain actually caused a bug or a success. Composer 2.5 addresses this with a method Cursor calls targeted textual feedback: instead of outcome-only signals, the training provides feedback at the specific point in an agent trajectory where behavior could have improved.

The synthetic data generation is equally interesting. One method is called Function Deletion: the process begins with a codebase rich with unit tests, an AI agent surgically deletes code and files to remove a specific testable feature while keeping the rest of the system runnable, and the synthetic task for Composer becomes the inverse , perfectly re-implementing the deleted functionality, using the pre-existing unit tests as a verifiable reward signal. This grounds the training distribution in real production patterns rather than toy examples.

On the infrastructure side, the pretraining also incorporates Sharded Muon with distributed orthogonalization and dual mesh HSDP, which Cursor says improves stability at scale.

The benchmarks

On benchmarks like SWE-Bench Multilingual (79.8%) and CursorBench v3.1 (63.2%), Composer 2.5 matches Opus 4.7 and GPT-5.5. The gains over Composer 2 are significant across the board:

• CursorBench v3.1: moved from 52.2% to 63.2%, an 11-point gain
• SWE-Bench Multilingual: moved from 73.7% to 79.8%, a six-point jump
• Terminal-Bench: a 7.6 percentage-point improvement, the product of 25x more synthetic training tasks and targeted textual feedback RL

One caveat worth flagging: the headline CursorBench v3.1 number is built, run, and scored by Cursor itself , the same entity authoring the model. The SWE-Bench Multilingual score is on a public benchmark, which provides more independent signal. And on terminal-heavy tasks specifically, shell scripting, Kubernetes automation, infrastructure-as-code, and Codex CLI tasks are where GPT-5.5 maintains a documented edge that Composer 2.5 doesn't close.

The cost story

This is where Composer 2.5 makes its clearest case. On benchmarks matching Opus 4.7 and GPT-5.5, Composer 2.5 costs $0.50 per million input tokens and $2.50 per million output tokens , a fraction of what Anthropic and OpenAI charge , with a faster variant running $3.00 and $15.00 respectively. For comparison, Claude Opus 4.7 sits around $15 per million input tokens and $75 per million output tokens, and OpenAI's GPT-5.5 plays in the same price band.

A two-million-token agentic session with a 70/30 input-output split costs $2.20 on Composer 2.5 Standard, versus tens of dollars for the same session on Opus 4.7 or GPT-5.5. For teams running parallel agents or long refactoring sessions, that gap compounds fast.

What you can do with it in Grok Build

Composer 2.5 is now available inside Grok Build as a fast, highly intelligent model that excels on long-running tasks and following complex instructions. The practical workflow commands available inside Grok Build include:

• /fork , clone the current session to a parallel sub-agent running a separate task simultaneously
• /compact , compress conversation history to reduce token usage during long sessions
• /copy , copy the latest response to clipboard
• Always-approve mode , auto-authorize file edits without manual confirmation on each step

When given natural language instructions such as "enhance the mobile responsive experience of the game loading menu,