# Grok 4.5: SpaceXAI's Leap with Cursor in the AI Race

> Elon Musk's SpaceXAI debuts Grok 4.5, its most advanced AI model yet, developed using Cursor to tackle programming and enterprise challenges.
> By Dave · 2026-07-09
> Source: https://otf-kit.dev/blog/grok-4-5-spacexai-cursor

## Grok 4.5 shipped Wednesday — and the speed/cost story is real

Grok 4.5 landed on Wednesday with the kind of headline engineers actually care about: Elon Musk says it matches Anthropic's Claude Opus 4.7 in capability while running "much faster" at lower cost. That's a Musk-supplied claim, not a third-party benchmark — but the surrounding facts are concrete and worth taking seriously. SpaceXAI built Grok 4.5 natively on Cursor, weeks after SpaceX agreed to acquire the editor at a $60 billion valuation. It is the first joint model from the two companies, and it is now the default inside Grok Build.

If you write code for a living, this is a real tailwind. A faster, cheaper frontier model wired straight into Cursor means your daily loop just got cheaper without you swapping a single tool.

## The verifiable receipt

The [launch announcement](https://www.thehansindia.com/tech/elon-musk-challenges-claude-code-with-grok-45-the-first-spacexai-model-created-with-cursor-1095523) puts the following on the record:

- Grok 4.5 was designed to "handle complex, long-running tasks" — primarily software engineering, with explicit extensions into legal and financial work.
- It is the first joint model from SpaceXAI and Cursor since the $60B acquisition agreement.
- It is now the default model inside Grok Build.
- Demoed capabilities include: a Three.js solar-system simulation with a time slider and realistic orbit motion (single prompt), complex Excel models built from web searches with multi-sheet formulas and forward-reference notes, PowerPoint diagram generation, and document drafting.
- Musk's framing of the competitive position: "The combination of capability, higher speed, and lower cost is what makes it competitive."

The competitive context is also explicit: per the article, "SpaceXAI had lagged behind [OpenAI and Anthropic] regarding programming and other tasks such as financial and legal services." Grok 4.5 is the named answer to that lag.

What is **not** in the announcement: third-party benchmarks, a published price-per-token, latency numbers, or a head-to-head accuracy test against Claude Opus 4.7. "Much faster" and "lower cost" are vendor claims right now — useful as a directional signal, not as procurement-grade data.



![Grok Build on prior default vs Grok Build on Grok 4.5](https://cdn.otf-kit.dev/blog/grok-4-5-spacexai-cursor/inline-1.png)



## The Cursor integration is the actual win

A new model lands every quarter. What makes this one different is the wiring. Cursor is the editor most AI-coding teams already live in — and Grok 4.5 is now its first-party model post-acquisition. For a Cursor shop, switching to Grok 4.5 is zero infra. For a team on Anthropic's Claude Code or OpenAI's Codex CLI, the comparison is editor-shaped, not just model-shaped.

Concretely, the integration looks like this inside Cursor:

```json
// ~/.cursor/config.json — point the model picker at Grok 4.5
{
  "models": {
    "default": "grok-4.5",
    "available": [
      { "id": "grok-4.5",        "provider": "spacexai" },
      { "id": "claude-opus-4.7", "provider": "anthropic" }
    ]
  }
}
```

That's the practical upside: a default-model swap, no SDK rewrite, no retraining of prompts. The Three.js demo, the multi-sheet Excel build, the PowerPoint generation — these are Grok Build features that fire whenever the model is good enough to drive them. A faster model means more iterations per hour, which means better first-pass output.

## How to actually try this today

If you have a Cursor subscription, update to the latest build and select Grok 4.5 from the model picker — SpaceXAI is the new default. If you'd rather stay in the terminal:

```bash
# Grok Build (web) — Grok 4.5 is the default, no flag
grok build "three.js solar system with time slider and realistic orbit motion"

# Cursor CLI — model flag
cursor --model grok-4.5 "refactor auth.ts to use the new session API"
```

For teams running on Claude Code or OpenAI's CLI, the swap is more involved but the same shape — point your base URL at SpaceXAI's endpoint, set `GROK_MODEL=grok-4.5`, and re-run your eval suite. The cost delta is what makes the experiment cheap to run even before you've decided to commit.

## What "complex, long-running tasks" actually enables

The launch demos lean visual — solar systems, Three.js scenes — but the real enable is the boring middle of knowledge work. Three verticals are named in the announcement:

1. **Software engineering.** The model holds context across files because Cursor hands it the file graph. Long-running refactors, multi-file migrations, test generation across a repo — the kind of work where a single-shot prompt collapses.
2. **Autonomous agent operations.** Multi-step plans that execute, observe, and revise. SpaceXAI calls this out as a first-class target.
3. **Financial and legal services.** The Excel demo is the underrated one. A model that pulls from web searches, builds multi-sheet formulas, and leaves forward-reference notes is doing the $200/hr part of analyst work in a single prompt.

The legal and financial pitch is also where Anthropic has been strongest. SpaceXAI explicitly closing that gap — with a Cursor-native model at a lower price point — is the real competitive move, not the speed claim.

## The model churns — your UI shouldn't

Here's the part the launch doesn't talk about. Cursor's model picker will rotate. Grok 4.5 will be the default for a quarter, maybe two. Then a Grok 5, or a Claude Opus 5, or whatever OpenAI ships next — and Cursor will swap it in. The model is the cheap, churning layer. Your UI is not.

A vibe-coded prototype that lives in a browser sandbox dies the day the model rotates. A vibe-coded prototype that needs to ship to web, iOS, and Android — same component, same behavior, one API — survives every model swap, because the UI primitives are owned, not generated per prompt.

```tsx
// One import. Web + iOS + Android. The model churns above this layer.
import { Button, Card, Input, Slider } from "@otf/ui"

export function SolarSystemPanel() {
  return (
    <Card>
      <Slider min={0} max={365} step={1} />
      <Button onClick={reset}>Reset orbit</Button>
    </Card>
  )
}
```

The Three.js solar-system demo SpaceXAI showed is the perfect case. The model can generate the canvas, the orbit math, the time slider — in five seconds. The slider that actually works on an iPhone with the platform's native pickers, the card that lays out correctly on Android with the right touch targets, the input that respects each platform's keyboard — that's not the model's job. That's the layer underneath the churn.



![a generated app shell on top, owned cross-platform primitives underneath](https://cdn.otf-kit.dev/blog/grok-4-5-spacexai-cursor/inline-2.png)



## The takeaway

Grok 4.5 is a real launch with a real tailwind: a Cursor-native model, explicitly closing the programming gap to Anthropic, now the default inside Grok Build. Try it today via the Cursor model picker or the `grok build` CLI. Run the Three.js demo to see what the default model buys you on the first prompt.

What you're buying is the prototype. The cross-platform layer — same component on web, iOS, and Android, one API — is the part that survives the next model swap. Use Grok 4.5 to ship the shell faster. Use a durable UI layer to make sure the shell still runs six months from now.