# SpaceX Acquires Cursor for $60B in AI Infrastructure Expansion

> SpaceX's $60B acquisition of Cursor marks a major move in AI infrastructure, expanding their AI compute capabilities.
> By Dave · 2026-08-14
> Source: https://otf-kit.dev/blog/spacex-cursor-ai-deal

$60 billion. That's the price SpaceX closed on Cursor on August 14 — and it doesn't fit inside the typical AI coding tool story. Cursor was a real product — an AI coding IDE for professionals, used by a large share of teams shipping production code. But SpaceX paid $60B for it, struck at that price from the moment SpaceX took its option in April. The closing matched the option. That's not a negotiation. That's conviction.

The headline is the price. The underreported half is *why*. SpaceX was already running SpaceXAI compute infrastructure by April. Cursor got access to it for model training. The merger is the second move in a sequence, not the first. SpaceX paid $60B to lock in a model-training partner that was already running on its compute.



![SpaceXAI compute → Cursor model training → Cursor IDE → developers, with the merger foldin](https://cdn.otf-kit.dev/blog/spacex-cursor-ai-deal/inline-1.png)



That's the angle worth pulling on.

## What Cursor is, and what SpaceX just bought

Cursor is the AI coding environment from Anysphere Inc. — the IDE, the tab autocomplete, the multi-file edits, the chat pane that reads your repo. It's among the most-adopted AI coding tools among professional developers. Per Cursor's own August 14 statement, the acquisition "completes the acquisition process that started in April, when we announced our partnership with SpaceXAI to accelerate our model training efforts."

So Cursor is not just a thin editor wrapping someone else's model. The company has model training operations. The SpaceX deal was structured to fold those into SpaceX's AI infrastructure, not strip them out.

The financial shape, from the Form 8-K filed with the SEC:

- Implied Cursor equity value: $60 billion
- Conversion: 389,289,254 SpaceX Class A shares for Cursor's common and preferred
- Vested RSUs: an additional 1,752,426 SpaceX Class A shares before applicable tax withholding
- Assumed unvested awards: ~29.1 million SpaceX RSUs plus ~44.4 million options to purchase SpaceX Class A shares
- Share price reference: volume-weighted average closing price over the seven trading days immediately before closing

The definitive merger agreement was signed June 16 between SpaceX, X67 Inc. (a wholly owned SpaceX merger subsidiary), and Anysphere Inc. X67 merged into Cursor; Cursor survived as the wholly owned subsidiary.

## What this enables for builders

This is genuinely exciting, and the part most coverage skims past. A frontier aerospace company putting $60B behind an AI coding platform changes the strategic picture for everyone building on top of AI coding tools:

- **Cursor's model training now sits on SpaceX-grade compute.** The company that needed access to SpaceXAI's infrastructure in April now owns that pipeline outright. Finetune cycles that took weeks may move faster, and the scale of the models Cursor can pretrain against just got larger.
- **The dev experience inside Cursor stays the product surface.** SpaceX didn't acquire Cursor to gut it. Cursor's August 14 statement is three sentences and doesn't promise a roadmap, but it also doesn't announce layoffs, a brand change, or a pivot. The IDE is the IDE.
- **SpaceX's AI infrastructure gets a real consumer-facing product.** SpaceXAI computing has been a back-end asset. It now ships through a developer product used by professionals shipping real code. That's a different kind of company overnight.

If you're already building on Cursor, none of your local workflow breaks. The acquisition is upstream of the product.

## How to actually use Cursor today

"Exciting" without a how-to is fluff. Here's the concrete:

```bash
# 1. Install Cursor
brew install --cask cursor
# or download from cursor.com — macOS, Windows, Linux
```

Sign in (or import from VS Code: `Cursor → Settings → Sync Settings → Import from VS Code`). Open a repo. The AI features light up. The keybindings worth memorizing:

- **`Cmd+K`** — inline generation at the cursor. The fastest way to write a function body, a test, a SQL query from a description.
- **`Cmd+L`** — chat pane. Repo-aware. Can read multiple files, propose edits, apply them across the workspace.
- **`Cmd+I`** — agent mode. Multi-step task execution. Runs shell commands, writes tests, refactors across files, fixes lint errors, opens PRs.
- **Model picker** — top-right of the chat pane. Switch per task. A cheap model for autocomplete; a frontier model for hard refactors or cross-file architecture work.

The pattern that actually saves time: keep the editor for the parts that need precise control — debugging, infrastructure, anything that touches prod — and let agent mode take the multi-file refactor and the "wire up this API" jobs.

```ts
// Agent mode scaffolding — give it the spec and the constraints
// "Generate a typed client from ./openapi.json with exponential
// backoff, zod validation on responses, and a Vitest suite"
import { z } from "zod"
import type { paths } from "./schema"

const RetryOpts = z.object({
  attempts: z.number().int().min(1).default(3),
  backoffMs: z.number().int().min(0).default(500),
})
```

Cursor's agent produces that in a few seconds when the context is pointed at it. The skill is in the prompt specificity, not in the typing.

## The part that doesn't change when the model does

Here's the thing worth saying out loud. Cursor is one of a half-dozen AI coding tools that matter right now. The model behind the chat pane will churn. The autocomplete provider will be swapped. The model picker in Cursor already exposes that churn — different models for different tasks, swapped daily.

What doesn't change is the **product layer above the tool**: the components, the auth, the data layer, the deploy pipeline. The repo Cursor writes to is the surface that survives every model swap.

That's the layer OTF is built for. The same component on web, iOS, and Android from one API. The same auth flow. The same backend contract. The AI tool generates the code; the repo is the artifact. The artifact is what ships.



![a single source of truth that survives the model churn — the repo, the component, the API ](https://cdn.otf-kit.dev/blog/spacex-cursor-ai-deal/inline-2.png)



Cursor accelerates the writing. The shipped application is the durable thing.

## What to watch over the next quarter

A few signals from the article's filing worth tracking:

- **The April option was $60B too.** SpaceX priced Cursor at $60B when it took the option in April. The closing price matched the option price. Read that as conviction, not negotiation.
- **7-day VWAP as the share-count denominator.** SpaceX used a volume-weighted average over the seven trading days before closing to determine the SpaceX share price. No last-minute pop, no last-minute dip. That's how SpaceX wants its equity used as currency.
- **Cursor's statement is short.** Three sentences. No roadmap, no pricing changes, no commitment language. The next thing to watch is the first post-acquisition roadmap post.
- **The 29.1M RSUs and 44.4M options assumed.** Real retention currency. Cursor's team has stake in SpaceX now. The next 18 months of Cursor's roadmap is, effectively, SpaceX's roadmap.

For now, keep using Cursor if you already are. The IDE is the same. The compute underneath it just got a lot larger.