xAI, the sleeping giant, and the coming war for agentic software work.

Many of you saw this coming. If you're confused about this deal, or think Cursor's valuation is overly generous, let me explain what’s happening backstage.

Software Engineering Is Changing

If you still think software engineering is mostly a person sitting in an IDE, manually working through tickets one at a time, you are already looking at the old world.

That workflow is not the frontier anymore - it's the legacy compatibility layer that's a product of the old William Gibson chestnut: “The future is already here – it's just not evenly distributed.”

The best developers are no longer simply writing code faster with an AI helper - the entire shape of what's possible for an IC software engineer has been upended at the frontier of agentic development. SWEs at the major labs and FAANGs of the world are operating in a way that's borderline unrecognisable from even 3 months ago. Individuals are decomposing intent, writing specifications, spawning agents, running parallel implementation tracks, auditing outputs, tightening harnesses, and turning what used to be a multi-week engineering cycle into a few days of orchestrated machine labour.

This is not “vibe coding”. That term was useful for about five minutes, back when the outputs were mostly toy apps, broken demos and LinkedIn slop. It is now actively misleading. The frontier workflow is not less rigorous than traditional software engineering. Done properly, it is more rigorous: more planning, more tests, more reviews, more adversarial audits, more security passes, more performance checks, more attempts to break the thing before a customer does. SaaS SMEs can legitimately optimise their apps at a level previously gated to the largest enterprises. The rate of progress recently feels like we're not far off non-technical PMs delivering kernel bypasses in their vibed MVPs because their 'performance engineering agent' told them it'd improve latency and well, that sounded good. The point is that we are no longer rate-limited by human hands.

Which is why the discourse around Cursor has been so funny. People are still trying to price it as an IDE. The VS Code fork for cool kids. A convenient place for developers to ask a model to edit a file. That was maybe true for a while, but it’s not true anymore.

Cursor is one of the best-positioned companies in the world because it sits exactly where the new software-production loop is forming: between capable users, real codebases, agentic models, accepted diffs, failed runs, tool calls, terminals, tests, reviews, and the daily reality of building software with machines.

That is what xAI has been sorely missing. Grok gave xAI attention, but Cursor gives it a path to victory.

The Old Workflow Is Already Dead

The traditional software development lifecycle was built around a very simple constraint: engineering was expensive, slow, scarce, and difficult to coordinate, so we wrapped it in ceremony.

Business analysts scoped requirements. Product managers wrote tickets. Engineers implemented them. QA tested them. DevOps got pulled in. Security arrived late and complained. Everyone sat in rituals pretending the process was more scientific than it really was, because the alternative was chaos and the bottleneck was human implementation capacity.

That world made sense when the unit of software production was the individual engineer. It makes much less sense when the unit of software production becomes the agentic workflow.

The frontier pattern now looks very different. You start with intent. You turn that intent into thoroughly stress-tested and documented requirements. You turn those requirements into PRDs. You turn those PRDs into implementation waves. You split the waves into issues. You give agents context, constraints, architectural rules, clear acceptance criteria, testing requirements, and explicit failure modes to avoid. You run implementation passes. You run audit passes. You run security passes. You run performance passes. You run documentation passes. You compare outputs. You reconcile diffs. You tighten the harness for anything that too often requires manual intervention. 

Then you do it again.

And again.

And again.

This is not a toy or hypothetical vibes-based workflow anymore. It is not “write me a todo app in React”. It is no longer limited to slop cannons spraying half-working TypeScript into the void. If that is still your mental model of agentic coding, you are not making a serious argument about the state of the tools. You are confessing that you have not learned the workflow. Skill issue. 

Yes, bad operators produce slop. But good operators... well. The best operators now compress work that would previously have required several developers and weeks of coordination (read: performative 'agile' song and dance) into days of heavily audited machine-assisted execution. Not because the models are magic. Not because software quality no longer matters. Exactly the opposite, actually. They do it because the work has moved up a level of abstraction.

The developer is less often the person typing every line of code. The developer is becoming the person who knows how to operate the factory. This is the point most of you are missing. The IDE is not disappearing. The loom did not make fabric disappear either. It changed where the leverage sat, who operated the machinery, and what counted as productive labour.

The IDE is becoming the needle and thread in a world of industrial looms - perhaps still the instrument of choice for the artisan, but unless you're the Louis Vuitton of software engineering, it's likely the wrong tool for the job.

Cursor Is Being Mispriced

The Cursor conversation has been so painfully shallow. People see a VS Code fork and ask why anyone would attach a serious valuation to it. Reasonable enough, if your understanding of the product froze in 2023, but Cursor is not valuable because developers like its sidebar. Cursor is valuable because it is sitting smack-bang in the middle of the new loop.

Every serious harness company wants the same thing: real users doing real work in real codebases, with enough volume and feedback to learn what actually matters. Not benchmark tasks. Not driving your disaster of an OpenClaw agent that burns 50K tokens every five minutes with a heartbeat routed to a multi-trillion parameter flagship model where the most taxing task at hand is to check and summarise your emails. Not “make me a snake game”.
Actual enterprise software work: huge, messy, poorly documented repos, broken tests, weird dependency chains, half-migrated systems, security constraints, product ambiguity, fragile infrastructure, and all the other things that make software engineering software engineering. That is where Cursor lives.

Cursor began as an IDE because that was where developers were, but the product gravity has moved. Autocomplete became chat. Chat became Composer. Composer became agent mode. Agent mode becomes background execution. Background execution becomes parallel orchestration. Parallel orchestration becomes the workbench.

At that point, calling Cursor an IDE is like calling Amazon a bookstore. Technically true once. Mostly useless now. Cursor is not an IDE - it's a workflow capture machine. It watches the power user in action. It sees the workflows they're running. It sees where models fail. It sees what developers accept. It sees what they reject. It sees which edits survive. It sees which terminal commands matter. It sees which failures cause users to interrupt. It sees the shape of software work as it actually happens, not as benchmarks pretend it happens. That is the prize.

The value doesn't really come from the product - it comes from the usage patterns of the userbase, and Cursor has a big one. 

Codex and Claude Code Are Training Machines

OpenAI and Anthropic understand this. It's why Codex and Claude Code matter so much, and both labs are pushing so heavily in their direction. They are not merely products. They are training machines.

Every serious developer using Codex or Claude Code in anger is teaching the lab something. They are revealing how capable users delegate work, how they structure tasks, which prompts survive contact with reality, where models need more autonomy, where they need tighter constraints, when compaction destroys intent, what kinds of mistakes remain unacceptable, and which tool-use patterns actually produce working software. This is almost certainly one of the reasons model capability in coding has been improving so violently since the start of 2026.

The models are getting better, yes. But the products around the models are also becoming vastly more important, and vasty more popular as a result - creating a virtuous cycle that compounds over time. The harness matters. The memory system matters. The terminal matters. The way the agent plans matters. The way it edits matters. The way it reviews itself matters. The way it recovers from a failed test matters. The way it preserves intent across a long run matters.

That is the thing the benchmark mythologising crowd keeps missing. They stare at leaderboards and miss the obvious fact that the best real-world coding agent is the system that can survive a large, messy, multi-hour implementation run without losing the plot. It needs to navigate a repo, understand the product, respect existing architecture, avoid creating accidental side quests, test its work, catch its own mistakes, document as necessary, and keep moving.

This is why Claude Code and Codex have felt so important. They are not just better ways to write code. They're not even necessarily just for code either - they're for putting models into action - whether that be software engineering, research, long-horizon task automation, or whatever else the users pushing these models to the limits want to achieve, and until now, xAI did not really have one.

Grok Got Attention. Cursor Gets Work.

xAI has never lacked spectacle. It had Elon. It had X distribution. It had Grok. It had compute. It had the “maximally truth-seeking” branding. It had the edgy consumer assistant with a personality. It had all the ingredients required to dominate the attention economy. The problem is that attention is not the same as work. Grok was built for attention. Claude Code and Codex were built for work, and that difference matters more than you may think. 

A consumer chatbot with a spicy personality can generate endless engagement. It can argue about politics. It can produce memes. It can go viral. It can entertain people in a feed. It can help xAI occupy mindshare. What it does not obviously do is teach a model how to refactor a monorepo, debug a broken test suite, migrate a database schema, understand a ten-year-old enterprise codebase, or complete a ten-hour implementation run without setting the curtains on fire. 

The highest-value behavioural data in AI is probably not “what did someone ask a funny chatbot on a social network?” It is “how did a savvy user delegate economically meaningful work to a model, and what happened next?”

Software engineering is the cleanest version of this because the loop is unusually rich. There is intent. There is action. There is feedback. There are tests. There are diffs. There are compilers. There are terminals. There are review comments. There is often a relatively clear distinction between “this worked” and “this broke everything”. That makes coding uniquely valuable as a training environment, and xAI, despite its compute advantage, has been strangely absent from that serious developer loop. Cursor changes the equation.

The Compute-for-Workflow Trade

The strategic logic of the Cursor deal is almost insultingly obvious once you stop thinking of Cursor as an IDE. Cursor needs compute. xAI needs the workflow. Cursor has distribution among developers. Cursor has the product surface. Cursor has the harness. Cursor has enterprise traction. Cursor has the usage loop. Cursor has the ability to see what agentic development looks like when competent people are actually trying to ship software. xAI has the compute ambition. That is the trade.

Cursor gets the ability to train and serve increasingly serious native models without being permanently dependent on the same frontier providers it is trying to compete around. xAI gets proximity to the thing it has lacked: serious, high-value, software-engineering usage. xAI gets a route into the behavioural loop. The patterns. The failures. The product telemetry. The reward signals. The workflow distribution. The shape of what  power users actually do with coding agents. That is more valuable than people realise. Raw code is useful. Behaviour is the gold.

The question is not simply “can xAI train a better model?” The question is whether xAI can combine massive compute with Cursor’s product loop to produce a coding system that is fast, cheap, native, and good enough that developers stop reaching first for Claude Code or Codex.

That is no longer a ridiculous question. It may actually be one of the most important questions in AI.

The Workbench War

The workbench is the product. 'Super app'. Whatever you wanna call it. OpenAI is not trying to win by giving you a nicer chat box. Anthropic is not trying to win by keeping Claude as a polite text interface for knowledge workers. The direction of travel is obvious: code, documents, research, design, data analysis, workflow automation, background jobs, tool use, company knowledge, personal context, long-running agents, and eventually whole chunks of knowledge work coordinated from one surface.

The end state is not chat. It is not CLI. It is not IDE. It is the AI workbench super-app that every working professional lives in because they can't imagine a world without it. A single place where a model understands what you are trying to do, has access to the right context, can operate tools, can run work in the background, can call in specialised agents, can produce artifacts, can inspect its own output, and can keep enough memory of your intent that you are not constantly re-explaining yourself to a very expensive goldfish.

OpenAI is moving there. Anthropic is moving there. Cursor may already be closer to the developer-native version of it than either. That's the important part. Cursor started with code because code is where the highest-agency users were. But the same pattern naturally expands. Once you have agents that can edit files, understand repos, run terminals, call tools, generate artifacts, reason over context, and coordinate long-running work, you are not very far from a general builder workbench.

Code is the sharp end of the spear. It will not stay the whole spear. This is where the xAI angle becomes more interesting. xAI does not need Grok to become everyone’s favourite chatbot. It needs a route into the workbench war. Cursor gives it that route. Whether this ends up branded as Cursor, Composer, Grok Code, X Code, or some other inevitable single-letter act of brand vandalism is almost beside the point. The direction is obvious.

Cursor becomes the developer-native workbench. xAI becomes the compute engine. The model layer becomes increasingly native. The product becomes less dependent on OpenAI and Anthropic. The usage gets cheaper. The limits get looser. The workflows get more parallel. The power users come for abundance. That is the threat.

Usage Is the Product

There is another reason this matters now. The current leaders are excellent, but they are beginning to feel expensive in the way scarce things feel expensive.

Claude Code is extraordinary when it is working well. Codex continues to improve at a frankly obnoxious pace. Both are good enough now that the limiting factor for many serious users is no longer “can the model do it?” but “how much of this can I afford to run?” That is a very different problem.

The future of agentic development is usage-hungry. It wants parallelism. It wants retries. It wants audit agents. It wants security agents. It wants performance agents. It wants independent review. It wants long-running implementation. It wants context-heavy planning. It wants to run the same problem from multiple angles and compare results.

If the best way to build software is to spawn ten agents, let them work, review each other, test everything, and keep going until the system is correct, then the winner may not be the model that scores three points higher on a benchmark. It may be the platform that lets you actually do that without feeling like you are committing financial arson. This is where xAI’s compute position matters.

Not because GPUs automatically equal intelligence. That is a lazy take. Compute is only useful if you have the training stack, data pipeline, serving infrastructure, product loop, and user distribution to turn it into capability. But once you do have those things, compute becomes a weapon. Cursor may be the product loop that lets xAI point the weapon somewhere useful.

And if Cursor can ship a native model that is not necessarily the best general model in the world, but is fast, cheap, deeply integrated, and potentially even better than the expensive frontier options for just software work, that is enough to change user behaviour. Developers do not need every task to be handled by the smartest model on earth.

They need the right model, in the right harness, with the right context, at a price and latency profile that lets them use it constantly. The best coding agent is not always the one that wins the leaderboard -it’s the one you can actually afford to run all day.

The API Trap

There is also a subtle strategic advantage in keeping the best workflow native. OpenAI and Anthropic have enormous API businesses, and those APIs are obviously valuable. They create ecosystems, integrations, distribution, and mindshare. But they also expose a lot of the model’s behaviour to the world. Developers can prod it, benchmark it, wrap it, automate it, abuse it, distil from it, and reverse-engineer at least some of the playbook. Cursor has a different opportunity.

A Cursor-native model does not need to exist as a general-purpose API product. It can be trained, served, evaluated, and improved inside the environment where the work actually happens. The valuable thing is not just the model response, it’s the whole system: the prompt scaffolding, the tool orchestration, the compaction strategy, the memory layer, the diff interaction, the review loop, the terminal behaviour, the UX interventions, the places where the human is asked to intervene and the places where they are not.

That is much harder to copy from the outside. This is why “model versus model” analysis is increasingly inadequate. A coding agent is not just a model. It is a socio-technical machine for turning intent into software. The model matters enormously, but so does the factory. Cursor has the factory. xAI has the power plant. You can see why they might want to talk.

The Grok Problem

The obvious caveat is that xAI has a brand problem. Grok is funny until it is not. The edgy assistant thing works well in consumer attention markets and badly in enterprise trust markets. The average CTO does not want quirked up, “truth seeking”, epic and BASED Grok anywhere near their production workflows. 

This is fixable, but it matters. The smart move is probably not to make Cursor feel like Grok in an IDE. That would be very on-brand for Elon, but it’d be braindead- and I don’t think he’s braindead. Cursor’s value is that serious developers trust it enough to put it near their work. Enterprise buyers do not want the model equivalent of a 4chan denizen with a GPU cluster. They want competence. They want reliability. They want privacy. They want control. They want the thing that their devs keep asking for. 

So the best version of this strategy keeps Grok as the consumer brand and lets Cursor remain the serious work surface. Maybe the underlying model is xAI. Maybe the compute is xAI. Maybe the post-training stack is increasingly shared. But the product should not inherit Grok’s worst instincts. Cursor gives xAI an enterprise-safe wrapper around its compute ambitions. The question is whether xAI can resist making it ass.

The Google Distraction

People will ask where Google fits into all of this. The honest answer is that Google remains obviously formidable. It has the talent, the infrastructure, the distribution, the research depth, the product surface area, and the internal reasons to care about coding agents. It would be silly to write them off.

But the zeitgeist is not evenly distributed. Among the people actually pushing agentic coding workflows hard, the conversation is dominated by Claude Code, Codex, Cursor, and the open-model insurgents. Google is present, but it does not feel culturally central to the developer-agent meta in the same way.

That can change. It probably will change. But right now, I think the interesting triangle is OpenAI, Anthropic, and Cursor/xAI. OpenAI has Codex and the ChatGPT surface. Anthropic has Claude Code and the high-trust model brand. Cursor/xAI has the chance to combine the developer-native product loop with obscene compute ambition. That is a real triangle, and it’s much more interesting than another round of benchmark screenshots.

The Sleeping Giant

For a while, xAI looked oddly mispositioned. It had money. It had compute. It had distribution. It had a founder who can bend capital markets, supply chains, satellites, rockets, cars, social networks and municipal permitting departments around his personal gravitational field, and yet in the part of AI that increasingly seems most important - software agents doing serious work - it did not have the loop.

OpenAI had Codex. Anthropic had Claude Code. Cursor had the IDE-turned-workbench. xAI had Grok posting. That was not enough, but the Cursor deal changes the shape of the board. It does not guarantee xAI wins, or even becomes competitive. Nothing guarantees that. Compute can be wasted. Product & research cultures can clash. Enterprise trust can be squandered. Privacy concerns can limit data access. OpenAI and Anthropic are not exactly asleep at the wheel. Google is far from dead. Open models are moving quickly. The whole market will inevitably look much different in six months because that is now how time works in AI.

If Cursor becomes the default surface for agentic software work, and xAI becomes the compute engine behind it, then the race is no longer simply OpenAI versus Anthropic. It is OpenAI, Anthropic, and the company everyone wrote off because Grok spent too long trying to be funny. That is the part people are missing. xAI may have just bought its way into the only loop that matters.