You can't procure the winner. So build what outlasts it.

Two things happened around the AI coding tools this month that look contradictory and aren't. SpaceX formally agreed to buy Cursor for 60 billion dollars in stock to strengthen its own coding tools against Anthropic and OpenAI. The same SpaceX is, since May, renting Anthropic the entire output of its Colossus data center for roughly 1.25 billion dollars a month. One company is simultaneously Anthropic's landlord and its competitor.

It only reads as a paradox if you think the coding tool is the product. It isn't. It's the distribution channel for a frontier model, and the frontier model runs on compute, and the same handful of companies increasingly own all three. The Cursor acquisition is not an event. It's the pattern arriving in public.

For most readers the soap opera is the least interesting part. The interesting part is what it does to a decision a lot of enterprises are in the middle of right now: choosing an AI coding tool, at hundreds or thousands of seats, through a procurement process that takes months - while the thing they're procuring re-shapes itself every quarter.

The tool layer is collapsing into the model

The independent coding-tool layer is being absorbed by the layer beneath it. Whoever owns the frontier model and the GPUs ends up owning the agent, because that's where the capability and the cost both live. So the labs bundle their own: Anthropic ships Claude Code, OpenAI ships Codex, and now SpaceX-xAI gets Cursor and Grok Build. An independent application sitting on top of someone else's model is, structurally, either an acquisition target or an also-ran.

The market data already shows the squeeze. Cursor is an excellent product with billions in annualized revenue - and its usage share still slid from roughly 41 percent in mid-2025 to around 26 percent a year later, while the lab-owned agents climbed. Being the best standalone tool was not enough to hold the ground against tools that come welded to the model they run on.

Completion didn't get better. It disappeared into the agent.

There's a temptation to split the market into a cheap, commodity "autocomplete" tier and an expensive "agent" tier, and treat the first as the safe, swappable layer. That tier is gone. Inline completion didn't lose - it dissolved into the agent. The tools now ship completion as a minor mode of an agentic product; you don't procure it, you inherit it. The standalone autocomplete you'd hedge with isn't a category anymore.

What's left where completion mattered is narrow: low-latency keystroke suggestion for teams that want assistance rather than autonomy, and local or air-gapped completion for data-sovereignty reasons. Real, but a niche, not a layer.

That matters because of where capability actually sits. It is not in the model alone. It's in the harness - the scaffolding that plans, reads the repo, edits files, runs tests, and iterates - and the strongest harnesses are co-designed, often co-trained, with a single model. A model-agnostic tool can route to the best model but can't co-optimize for it, so it leaves capability on the table. Selecting Claude inside a model-agnostic wrapper is not the same product as Claude Code. Model-agnosticism is not capability.

Which quietly breaks the enterprise playbook

The standard way large organizations buy developer tooling assumes the market sits still long enough to evaluate it. This one doesn't. Every move in the familiar playbook now works against you.

The old enterprise playbook	Why it breaks in 2026
Pilot, then standardize on the current leader	The leader changes faster than the procurement cycle that's choosing it
Lock a multi-year deal for price certainty	Pricing is moving to usage-based; the meter, not the rate, is the exposure
Hedge with a cheap inline-completion tier	Completion dissolved into the agent - there's no commodity tier to fall back to
Treat the tool as a swappable line item	Capability lives in a co-designed harness you can't hot-swap without losing it

Put plainly: you can't procure the winner, because by the time the contract is signed the winner has moved, and there's no longer a cheap swappable layer to retreat to. The whole purchase is a bet on one or two agentic harnesses, with real lock-in. That sounds like a trap. It mostly isn't - because the thing worth protecting was never the tool.

The hedge didn't disappear. It moved.

Here is the part that the lock-in framing misses, and it's the most useful thing to take away.

Agents are stateless by design. Every session starts cold; the context window resets; nothing the agent learned about your system survives on its own. The entire discipline that grew up around these tools - now usually called context engineering - exists to solve exactly that: get the important state out of the disposable conversation and into durable storage the agent reloads each time.

The consequence for procurement is the one most buyers miss. The expensive thing an agent does is understand your system. That understanding does not have to live inside any one tool's session. If you externalize it into owned, tool-agnostic artifacts, a fresh session in any harness rehydrates from your context instead of crawling the codebase to re-derive it. And the industry has standardized the artifacts that make this portable:

• Cross-tool instruction files. AGENTS.md was released by OpenAI in 2025 and handed to the Linux Foundation's Agentic AI Foundation; it's now read by thirty-plus agents - Codex, Copilot, Cursor, Gemini, Windsurf, Devin, and Claude Code via import. One file, every agent. It exists precisely so your project context isn't trapped in one vendor's format.
• Portable skills. The SKILL.md format carries reusable procedures across Claude Code, Codex, Copilot and others, loaded on demand rather than stuffed into every prompt.
• The issue tracker as memory. Tickets give agents what a chat can't: persistent state, ownership, and queryable history, with comments acting as the handoff record between sessions and between agents. Copilot, for one, already reads a Linear issue's full description and comments as the context for the work and writes the result back. The tracker becomes the project's long-term memory, not just its to-do list.
• Traceability of what the agent did. Emerging attribution specs record AI-versus-human authorship alongside the code, so the reasoning behind a change survives the session that made it.

Build that layer and moving from Claude Code to Copilot - or to whatever gets acquired into existence next quarter - is close to trivial, because the moat was never the harness. It was the context substrate and the judgment that produced it.

One honest caveat, and it's the point. This only works if the context is hand-built by people who understand the system. A controlled study this year found that auto-generated context files actually lowered task success versus no context at all, while hand-written ones improved it. You cannot scaffold your way to this. It's an experience asset - it accrues to a team that has worked in the system long enough to know what's worth writing down. Which is also why it's the part a tool change can't take from you. (How to build that layer in practice - file structure, the per-session workflow, traceability discipline - is its own article; here it's enough that it's where the durability lives.)

What the months are actually for

If the tool is rented and the context is owned, the long procurement cycle should harden everything around the tool, not the choice of tool. Four things deserve the time:

• Spend governance. The cost structure inverted. Completion was flat and cheap; agents are metered and expensive - they burn tokens orienting in the repo before writing a line. At thousands of seats, the meter is your real exposure, so caps, routing, per-workflow visibility, and committed-use terms matter more than the headline rate.
• Verification gates. Agents ship pull requests, not line suggestions, and a green PR can still semantically break a downstream consumer. CI gates, review discipline, and provenance are now first-order procurement criteria, not afterthoughts.
• Contract terms built for volatility. Short initial terms with real exit ramps over multi-year lock-ins; price caps; and data, IP, and portability guarantees. Note where portability now lives: at the contract and data layer, not in the fantasy of a swappable agent.
• Vendor-continuity as a first-class criterion. Cursor's absorption is the lesson - an independent tool can be flipped under you mid-contract. A tool owned by a lab with its own models and compute has clearer multi-year continuity than a standalone acquisition target. Weigh it against capability, but price it in.

Seat allocation belongs in the same frame: tier to actual usage rather than blanket-licensing the top plan, because that's where scale either overpays or deepens the lock-in.

The line

The mistake isn't picking the wrong AI coding tool. It's spending a months-long process picking the tool at all, in a market that re-decides the winner faster than you can buy one. Spend those months on the things that outlast any tool - what the agent costs, what it's allowed to ship, and the context layer that lets a fresh session in any agent pick up where the last one left off. Rent the tool. Own the context, and the judgment that builds it.