Cursor updated its team pricing on June 30th, effective for renewing customers starting July 1st. The change is easy to skim. Two seat tiers — Standard at $40 per user per month, Premium at $120 — and on every seat, two separate usage pools. A "first-party models" pool covering Cursor's own tools and, as of this month, Grok 4.5. A "third-party API" pool for Claude, GPT, and Gemini.
That distinction between first-party and third-party is doing a lot of work, and it didn't get there by accident.
What Gets Called "First-Party"
Cursor's first-party pool includes Auto mode, Composer 2.5 (Cursor's own agentic model), and Grok 4.5. Third-party includes Claude, GPT, and Gemini — the models from Anthropic, OpenAI, and Google that the majority of Cursor's power users have been routing their heaviest work through.
Grok being first-party is the tell. On June 16th — two weeks before this pricing change — SpaceX agreed to acquire Cursor's parent company Anysphere for $60 billion in stock. SpaceX had already merged with xAI, Elon Musk's AI company that builds Grok. The corporate structure that would eventually make Grok the "native" model inside Cursor's billing system was already in place before the pricing update dropped.
The three models that compete most directly with Grok — Claude, GPT, Gemini — are now in the "third-party" bucket. They're still available. Cursor is not removing them. But they're priced differently from the model that the new corporate owner happens to make. That's a meaningful structural signal, even if no individual model capability changes in the next ninety days.
What $60 Billion Buys When You Don't Own a Model
To be clear about what SpaceX acquired: Cursor does not train frontier AI models. Composer 2.5 is a specialized agentic model built on top of underlying capabilities, not a foundation model competing with Claude or GPT. The vast majority of Cursor's compute, until very recently, has been purchased from Anthropic, OpenAI, and Google at API rates and resold to customers.
What Cursor built on top of that compute is the orchestration layer: the parallel agent management console that Cursor 3 launched in April, which made the Agents Window the primary interface and demoted the code editor to a secondary surface. Cloud Handoff, which moves agent sessions between local and remote environments without losing context. Multi-repo workspaces. The unified sidebar that shows you active local agents, cloud agents, remote SSH agents, and tasks triggered from your phone, Slack, or GitHub — all in one place.
Cursor crossed $4 billion in annualized revenue while renting its intelligence from competitors. SpaceX paid $60 billion for the thing Cursor owned outright, which is not any particular model but the developer workflow built around a specific orchestration interface. Three million professional developers who have reorganized how they work around Cursor's agent management console. That's what the number is pricing.
The underlying logic isn't novel — it's the same bet that made AWS more valuable than any hardware vendor. When compute commoditizes, the infrastructure that routes and manages it concentrates value. When AI models commoditize, the infrastructure that orchestrates them does the same.
Lock-in Has Always Been About Workflow
When developers talk about tool lock-in, they usually mean data. Notion keeps your pages. Linear keeps your issues. Migration is tedious because you have to move the data.
Agentic coding tool lock-in works differently. The data you've accumulated in Cursor is minimal — some rule files, some configuration, maybe a project context doc. None of it is heavy to move. The thing that's hard to move is you.
Your Cursor rules. Your agent workflow patterns. The mental model you've built for how to decompose a feature into parallel tasks, in what order, with what degree of specification up front. The shortcuts you've internalized on the Agents Window. The specific ways you've learned to prompt this particular orchestration interface to get useful output.
None of that is portable. It lives in your habits and your configuration, not in any database a migration tool can reach. A developer who has spent six months building workflows around the Cursor Agents Window is not neutral about which tool they use. They've invested in one specific orchestration environment. Switching to Claude Code or Antigravity means rebuilding those patterns from scratch, with different interface conventions, different agent management paradigms, different ways to inspect and redirect work in flight.
The pricing change makes this relationship explicit. The first-party pool is cheap and generous. The third-party pool is separately metered at market rates. Cursor is not forcing anyone off Claude — but it is creating a pricing structure that rewards building your workflow around Cursor's own tools rather than using Cursor as a thin routing layer to Anthropic's API.
That structure will get more pronounced as the xAI integration deepens. The practical version of vertical integration in AI development tools isn't locking out competitors — it's pricing your own stack as infrastructure and everyone else as a utility.
What You Pay For When the Bill Splits in Two
For teams evaluating AI tool ROI, the billing split creates a new accounting problem. You'll have your Cursor Teams invoice separated into first-party usage and third-party API usage. You'll have your commit history and PR velocity from GitHub. What you won't have is any clear connection between the two.
This isn't new. Attributing productivity to AI tools has been difficult since the tools appeared. The METR study found that experienced developers were 19% slower on real tasks when using AI tools while believing they were 20% faster — a 39-point perception gap that held even immediately after task completion. If a 19% slowdown is imperceptible during and after the task, the difference between Cursor's Composer 2.5 and Claude on the same agentic task is invisible to self-report.
What the split billing does is add granularity to a measurement problem that was already unsolvable by feel. Teams will know that $1,200/month went to Cursor Standard seats and $340/month went to third-party API calls through the platform. They will not know whether the first-party model or the third-party model drove the PR that shipped the feature. They will not know whether the orchestration layer's Cloud Handoff feature saved two hours of context-switching overhead, or whether a different tool's architecture would have produced the same PR in the same time at lower cost.
The instrumentation exists at the model layer (token usage), at the agent layer (commits, PR velocity, merge rate), and at the individual keypress layer (editor plugins, WakaTime, coding time trackers). The decision layer — what a developer chose to delegate, when they interrupted an agent, how much preparation went into a task before any agent ran — remains invisible in all of them.
The Attribution That's Still Missing
Cursor's new pricing gives teams more visibility into their spend breakdown. What it doesn't change is the underlying measurement gap: distinguishing the value of the tool from the value of the model from the value of the developer's judgment about how to use both.
That gap matters now in a way it didn't before, because the tool and the model are being separated not just conceptually but commercially. When you paid one flat subscription for Copilot and the model it was running underneath was Microsoft's concern, the question of "was it the orchestration or the model" was academic. When Cursor is charging you separately for Composer 2.5 and for Claude, the question has an invoice attached.
The honest answer is that neither the billing data nor the output data can answer it. You'd need to track what the developer decided, not just what the agents produced. You'd need to measure the quality of task decomposition, the effectiveness of specification work, the rate at which in-progress agent sessions required human redirection. Those signals exist in a developer's working patterns. They don't surface in any dashboard anyone currently ships.
What Cursor's pricing split reveals is that the AI coding tool stack has matured enough to have a visible internal value chain: orchestration separate from intelligence, first-party separate from third-party, the tool separate from the model. That's progress in transparency. The measurement problem it exposes is real. A cleaner invoice doesn't tell you what's producing the output. It just makes the question harder to ignore.