xAI and Cursor teamed up to train a programming model, which will be available on both Cursor and Grok Build.

xAI and Cursor Trained a Model Together

Late at night on June 15, xAI and Anysphere (Cursor’s parent company) simultaneously announced: the jointly trained next-generation programming model has been completed. It will first be launched in the Cursor editor and Grok Build command-line agent, with SuperGrok or Cursor Pro subscribers getting priority access.

This wasn’t sudden, but the rollout speed was much faster than the industry expected.

Looking back at the timeline: In April, xAI and Anysphere signed an option agreement allowing xAI to acquire the entire Cursor team and product for $60 billion in the second half of 2026; backing out would require paying a $10 billion penalty. At the end of May, Musk hinted at Grok 5 in a livestream, mentioning that a large amount of Cursor programming data had been fed into the training corpus. In early June, the early Beta of Grok Build integrated Cursor’s self-developed Composer 2.5. And now, both companies have gone one step further to train the model together.

This is a clear path from “buying data” to “buying the team” to “jointly training a model.” In other words, the so-called “acquisition option” increasingly feels like a formality — technically, xAI and Cursor are already deeply coupled.

What Model Was Actually Released This Time?

Neither company has given the model an official product name; internally, it is codenamed Composer 3 (Cursor continuing the Composer series naming) and Grok Code (xAI’s external naming). Based on feedback from developers who have already accessed the Beta and scattered data points released by both sides, we can roughly outline it:

• Parameter scale: MoE architecture with a total parameter count in the 600 billion range, ~70B active parameters. This size matches the coding tier of Claude 4.5 Sonnet and GPT-5.1, not aimed at general conversation flagships.
• Context window: 256K, combined with Cursor’s codebase indexing and Grok Build’s workspace tracking mechanism, long project repos can basically be stuffed in all at once.
• Training data: Besides conventional open-source code corpus, the most valuable is Cursor’s accumulated “human-AI collaboration traces” — how developers accept completions, modify diffs, reject model suggestions, re-prompt — these process data are heavily leveraged during RLHF.
• Inference path: Natively supports agentic loop; a single task can do long-chain planning, tool calls, self-validation — unlike early Composer versions which relied on outer Cursor Agent scheduling.

The real differentiation lies in training data. Cursor is currently the most-installed AI programming editor, generating tens of millions of human-model programming interactions daily. These data are far more valuable than static GitHub code — the former is “process”, the latter is “result.” For OpenAI and Anthropic to get equally high-quality data, they must either build their own IDE (GitHub Copilot is already legacy baggage) or pay to buy.

xAI simply paid to lock one down.

Dual Product Rollout: Cursor Editor + Grok Build

The model is being launched in two product forms, stemming from two different product philosophies.

Cursor’s side follows the embedded IDE route — the new model will be the default Auto option, focusing on diff edits inside the editor, multi-file transformations, long-chain agent tasks. Cursor’s own description: “About 23% higher completion success rate on long agent tasks than Composer 2.5, with 18% lower end-to-end latency.” If these numbers are accurate, Cursor will likely climb higher on SWE-bench Verified.

Grok Build’s side is a CLI agent form — similar in positioning to Claude Code and OpenAI Codex CLI — running directly in the terminal, handling commits, running tests, modifying CI configs. The previous Grok Build version was v0.2.11; with this new model it jumps to v0.3, adding a native sandbox runtime environment and remote worker pool.

The two product lines share the same model backbone, but upper-layer prompt engineering, tool definitions, and memory mechanisms each follow their own path. This “same model, different form” approach is deliberate: thicken the model layer, keep the product layer light — when iterating, upgrading the model once benefits both products.

How Does It Compare to Competitors?

As of mid-2026, programming models have become their own competitive track:

| Model | Form | Main Scenario | SWE-bench Verified (approx) | |-------|------|---------------|-----------------------------| | Claude 4.5 Sonnet | General + Programming | Agent long tasks | ~74% | | GPT-5.1 Codex | Programming specialized | IDE & CLI | ~72% | | Gemini 3 Pro | General | Multi-modal + code | ~68% | | Composer 2.5 | Programming specialized | Embedded in Cursor | ~69% | | This new model (est.) | Programming specialized | Cursor + Grok Build | ~75%+ |

If the official numbers are true, this will be the strongest open/commercial hybrid programming model currently on SWE-bench — note, it’s not open source, but can be externally called via Grok Build’s API.

It’s worth noting that the actual feel of programming models is increasingly detached from benchmarks. After hitting 75% on SWE-bench Verified, remaining differences come down to specific engineering feel: “is it pleasant to use daily,” “does it randomly delete code,” “can it correctly interpret private libraries,” etc. Cursor’s dominance over Copilot in the editor market isn’t because of the model, but because of product and data flywheel — this joint training with xAI means part of that data flywheel becomes a model moat.

API Access Methods

The new model’s launch in Grok Build is accompanied by its inclusion in the Grok API. Model ID: grok-code-1, using standard OpenAI-compatible protocol. OpenAI Hub has already gone live; domestic developers can directly call it with Hub’s unified key, avoiding overseas node hassles.

from openai import OpenAI

client = OpenAI(
    api_key="your-openai-hub-key",
    base_url="https://api.openai-hub.com/v1"
)

resp = client.chat.completions.create(
    model="grok-code-1",
    messages=[
        {"role": "system", "content": "You are a senior engineer. Edit code precisely."},
        {"role": "user", "content": "Refactor this function to use asyncio instead of sync IO:\n\ndef fetch_all(urls):\n    return [requests.get(u).json() for u in urls]"}
    ],
    temperature=0.2,
    max_tokens=2048
)

print(resp.choices[0].message.content)

Agent mode with tool calling is also supported — parameters match GPT-5.1’s setup, no need to rewrite adaptation layers:

tools = [{
    "type": "function",
    "function": {
        "name": "run_shell",
        "description": "Execute a shell command in the project sandbox",
        "parameters": {
            "type": "object",
            "properties": {
                "cmd": {"type": "string"}
            },
            "required": ["cmd"]
        }
    }
}]

resp = client.chat.completions.create(
    model="grok-code-1",
    messages=[{"role": "user", "content": "Run the unit tests and fix failing cases"}],
    tools=tools,
    tool_choice="auto"
)

Pricing: xAI’s official rate is $3 / million tokens input, $12 / million tokens output — slightly lower than Claude 4.5 Sonnet, slightly higher than GPT-5.1 Codex — sitting at the median for the “programming flagship” tier.

What’s the Real Meaning of This?

On the surface, it’s just another programming model launch. Looking deeper, there are several signals worth attention from the AI industry:

First, programming models have evolved from “big companies’ side projects” into “dedicated tracks.” Claude has a separate team for Code, OpenAI rebuilt Codex, xAI directly locked in an IDE company for $60 billion. Programming is currently the most clearly ROI-positive scenario for agents — developers are willing to pay, effectiveness can be quantified, usage frequency is high. Model companies without differentiation here risk losing the most sticky paying users.

Second, IDE data is becoming the “shale gas” of next-generation training resources. Static code has already been mined thoroughly; marginal gains from scaling up corpus size are dwindling. Every acceptance, rejection, and rewrite by developers in IDEs is high-quality preference data, directly feedable into RLHF/DPO. Cursor’s volume of data is something OpenAI and Anthropic can’t replicate soon.

Third, xAI filled its gap in the fastest way. Musk’s xAI has long been criticized for being weaker than OpenAI and Anthropic in general conversation and multi-modal, but for programming they intend to leapfrog via acquisition. If the $60 billion actually drops later this year, the Grok team instantly gains a top-tier programming model team, a nine-digit MAU IDE user base, and massive training data — things engineering efforts alone can’t produce.

Fourth, for developers, choices are increasing but so is decision cost. For the same coding task, you can use Claude Code, Cursor Agent, Codex CLI, and now Grok Build. Functionality is converging; differences lie in “feel.” The suggestion is: don’t pick sides; try each new model for a couple of days, use whichever feels smooth — this is also why aggregation layers like OpenAI Hub have value: at least you don’t have to swap keys.

Some Reservations

Finally, a few cautionary notes.

Joint training sounds romantic, but the cooperation model hasn’t been fully disclosed. Does Cursor have full access to model weights? What’s the data revenue-sharing mechanism? Can xAI, after obtaining the model, independently fine-tune and redistribute? — none of these details have been revealed. If the $60 billion acquisition doesn’t happen, will Cursor get its own flagship model, or only a version granted by xAI’s “benevolence”?

Beta-stage experience data also need to be viewed with skepticism. Early Betas usually run cherry-picked examples; when the model is deployed widely to all Cursor users, stability in long-tail tasks is the real test. Composer 2.5, for example, looked good at launch but was later criticized by developers for “forgetting” during long agent tasks.

So — the new model is promising, but don’t rush to switch all projects. Wait for official GA, third-party benchmark replication, and real user feedback on Reddit before deciding to migrate.

References

• SpaceXAI and Cursor jointly trained a model, to be released in Cursor and Grok Build (linux.do) — First domestic developer community discussion on the matter
• Grok’s latest model gets a “bonus” from Cursor; Musk: Coding sees huge improvement (Zhihu column) — Background on early Grok Build Beta integration with Cursor data