Elon Musk’s Grok 5, Cursor, and the brutal new phase of the AI coding race

Elon Musk’s xAI has quietly finished training what looks like its next flagship model, often referred to as Grok 5: a 1.5 trillion-parameter system aimed squarely at the AI coding race. It’s not just bigger—xAI has reportedly trained it on massive amounts of real-world programming data from Cursor, one of the most widely used AI coding tools in the enterprise.

At the same time, DeepSeek is showing what near-autonomous research agents can do, and Alibaba’s Qwen 3.7 Max has suddenly jumped into the global top tier of coding models. All of this is colliding in a single month where OpenAI, Anthropic, Google, and xAI are all lining up major releases.

Grok’s 1.5T model: what xAI is really building

Late on May 24, Elon Musk announced that a new Grok model with 1.5 trillion parameters had finished training, roughly three times the size of the current 500B-parameter version. xAI is targeting a public release within a few weeks.

Size alone isn’t the main story, though. What makes this model interesting is the data: xAI reportedly trained it using a huge volume of interaction logs from Cursor, the AI coding environment used by more than two-thirds of Fortune 500 companies. Cursor isn’t just a code autocomplete tool—it captures how real engineers search, refactor, debug, and collaborate across large codebases.

That means Grok isn’t only learning how to produce code that “looks right.” It’s learning from:

• Developer prompts and questions
• Code context across multiple files
• Editing and refactoring patterns
• Debugging sessions and fixes
• End-to-end task completion workflows

In other words, xAI is trying to teach Grok to behave more like a senior engineer who understands real projects, not just isolated snippets.

Why Cursor data is such a big deal

Cursor has quickly become one of the most important AI tools for developers. It’s expected to reach around $6 billion in annualized revenue by 2026, and Nvidia’s Jensen Huang has publicly called it his favorite enterprise AI service.

Training on Cursor-style data is like preparing for a coding exam with access to millions of worked examples from expert developers. Instead of just learning syntax, Grok can see:

• How humans break down complex tasks
• Which suggestions get accepted or rejected
• How bugs are diagnosed and fixed over time
• How large projects evolve across many files

This kind of data is exactly what’s needed to move from “AI that writes code” to “AI that actually engineers software.”

Musk’s Cursor play: data, infrastructure, and Grok Build

xAI’s move on Cursor isn’t just about training data—it’s part of a broader strategy. On April 21, SpaceX agreed to a deal that gives it an option to acquire Cursor for around $60 billion. Even if the option isn’t exercised, there’s a $10 billion cooperation fee on the table, which shows how seriously Musk values AI programming tools.

The partnership already lets Cursor tap into xAI’s Colossus compute infrastructure, which Cursor says solves a major bottleneck: lack of compute to scale its own models. At the same time, xAI gets access to extremely valuable programming interaction data.

On May 14, xAI launched Grok Build, a terminal-level AI programming agent that runs from the command line. It supports:

• Code generation and editing
• File and dependency management
• Shell command execution
• Up to eight sub-agents working in parallel

Grok Build is priced at $300/month for the top-tier subscription (with a temporary $99/month promo) and is natively compatible with the same configuration format used by Claude Code. That’s a notable move: xAI is explicitly making its tools plug into a competitor’s ecosystem rather than trying to wall everything off.

Can Grok catch up in the coding race?

Despite the hype, Grok is still behind the current leaders in coding benchmarks and enterprise adoption.

On the SWE-bench Verified benchmark, which measures how well models solve real GitHub issues:

• GPT 5.5 scores around 88.7%
• Claude Opus 4.6 is around 80.8%
• The Grok 4 series sits roughly between 72–75%

In enterprise usage (as of March 2026):

• OpenAI: ~55% of enterprise users
• Anthropic: ~47% (up from 20% a year earlier)
• Google: ~39%
• Grok: ~6%

Tripling parameters and adding high-quality Cursor data could be a genuine step change, but xAI is starting from behind. If you want more background on how Grok evolved to this point, it’s worth reading this deep dive into Grok 4.3 and xAI’s earlier model strategy.

The timing: Grok, Cursor, and the SpaceX IPO

The rollout of xAI’s new model and its Cursor partnership is tightly linked to a much bigger financial move. SpaceX is planning a NASDAQ listing on June 12 with a target valuation of around $1.75 trillion, which would be the largest IPO in history if it lands.

The $60 billion Cursor acquisition option is expected to close within 30 days after the IPO, and the new Grok V9 Medium release is scheduled just before that listing. In parallel, xAI has reportedly told employees to limit direct contact with Cursor staff to what’s strictly necessary for the technical partnership—standard behavior to avoid antitrust issues while a potential acquisition is under review.

So while Grok’s technical progress is important, it’s also part of a much larger story about Musk’s AI ambitions across xAI, SpaceX, and Tesla. For a broader look at that power struggle, see this breakdown of Musk, OpenAI, and the global AI race.

June’s model showdown: OpenAI, Anthropic, Google, xAI

Grok’s new model isn’t launching in a vacuum. June is shaping up as a rare month where four major labs are all pushing new frontier systems at once:

• OpenAI: GPT 5.6 has reportedly appeared in internal tooling with a 1.5M token context window already tested. Prediction markets put the odds of a June release above 85%.
• Anthropic: Claude Opus 4.8 has shown up in Google Vertex AI’s background, suggesting an upgrade is close.
• Google: Gemini 3.5 Pro is also scheduled for a June launch.
• xAI: Grok’s 1.5T model is slated for public release in the same window.

That means developers, enterprises, and tool builders are about to get a wave of new options—and a lot of benchmarking and migration decisions to make.

DeepSeek’s 99% AI-written research paper

While the big labs battle over models, DeepSeek just demonstrated how far autonomous research agents have come. Senior researcher Deli Chen released a 46-page survey paper titled “From Co-pilots to Colleagues: A Survey of Autonomous Research Agents,” and openly stated that about 99% of it was written by his own agent framework, Deli Auto Research Skill.

The stats are striking:

• 6 total iterations (4 with DeepSeek V1, 1 with V2, 1 with V3)
• First full draft in 76 minutes
• 6 days end-to-end, with ~108 rounds of agent interaction
• ~648,000 tokens consumed
• 2,234 lines of LaTeX generated
• 103 references verified
• 7 figures and 4 tables across 46 pages

Chen estimates his own actual “thinking time” at under two hours. The paper lists DeepSeek V4 Pro as a co-author for text and GPT Image 2 for figures, turning the paper itself into a live demo of the technology it surveys.

How the paper classifies research agents

The survey introduces a five-level autonomy scale for research agents, similar to how self-driving cars are classified:

• Level 1 – Autocomplete: Tools like GitHub Copilot that suggest completions while humans drive every step. Big productivity boost, zero autonomy.
• Level 2 – Task execution: The human defines a task and approves each action. Think ChatGPT or Claude Chat with tools enabled.
• Level 3 – Multi-step with checkpoints: The agent plans and executes multiple steps but pauses at defined checkpoints for human review. This is where tools like Claude Code and Cursor’s agents sit.
• Level 4 – Full autonomy in a bounded domain: Humans set the goal and evaluate the final result. Systems like Devin, AI Scientist, and SUI Agent fall here.
• Level 5 – Self-directed research: The agent chooses its own problems within a broad area. This remains mostly theoretical.

The paper also describes four common architectural patterns:

• Single-agent loops: One agent cycles through plan → act → observe → reflect.
• Multi-agent collaboration: Different agents take on roles (planner, critic, executor) and review each other’s work.
• Hierarchical orchestration: A supervisor agent breaks tasks into subtasks and delegates to workers.
• Tool-augmented execution: Agents call external tools like code runners, browsers, databases, or even lab equipment.

Most powerful systems combine several of these patterns.

What still doesn’t work in today’s agents

Despite the impressive demo, the paper is blunt about what’s still broken. It highlights six unsolved problems:

• Cognitive loop traps: Agents often get stuck repeating failing strategies (a classic AutoGPT issue).
• Context limits: Long research sessions can easily exceed 100,000 tokens, causing early information to be lost or misremembered.
• Novelty evaluation: It’s hard to tell if AI-generated research is truly new or just a remix of obscure work.
• Reproducibility: Non-zero temperature and prompt sensitivity make it difficult to reproduce exact results.
• Safety and ethics: The same tools that accelerate research can also accelerate dual-use or harmful work.
• Cost and access: Even a single SWE-bench resolution can cost $5–$50 in API calls, putting advanced agents out of reach for many.

After surveying 95+ papers and 17 major systems, the conclusion is that most frontier agents are operating at Level 4—autonomous within a bounded domain—but Level 5, truly self-directed research, is still aspirational. The blockers aren’t just raw model power but long-term memory across sessions, reliable self-critique, and architectures that scale to complex projects without collapsing.

Alibaba’s Qwen 3.7 Max crashes the global coding leaderboard

While Western labs fight for the top spot, Alibaba’s Qwen 3.7 Max just made a quiet but historic move. On the Code Arena leaderboard, it scored 1,541 points and landed in fourth place globally—beating GPT 5.5 and Gemini 3.5 Flash. Only Claude Opus 4.7 and 4.6 are ahead of it.

This is the first time a Chinese model has reached this level in programming performance, and Qwen 3.7 Max is currently the only non-Claude model in the global top five.

Real-world coding tests: Tetris, 3D worlds, and racing games

Developers have been stress-testing Qwen 3.7 Max with practical tasks, and the results are notable:

• Self-training Tetris AI: In one comparison against Opus 4.7 and GPT 5.5, Qwen 3.7 Max not only outperformed both but did so at a token cost of just $1.32 while improving performance by 56%.
• 3D universe model: Another developer used it to build a 3D model of the universe. Qwen 3.7 Max delivered strong visual quality and speed, especially when generating a 3D pixel-style pagoda model.
• HTML racing game: Given a prompt to build a browser-based racing game, Qwen 3.7 Max produced a playable HTML file on the first try, with only a minor bug (left/right controls reversed) that was fixed in one follow-up.

The final racing game included:

• Four cars and a three-lap circular track
• 100+ gold coins scattered around
• Obstacles that slow the car when hit
• A results screen with rankings, lap times, coin count, and fastest lap
• A proper start page with a clickable “Start” button
• Engine and coin-collection sound effects, which were only lightly specified in the prompt

By contrast, competing models showed quirks:

• Gemini 3.5 Flash: Lower visual quality and cluttered UI with HUD elements in all four corners.
• Claude Opus 4.6: Very few coins and AI cars that moved almost in perfect sync.
• GPT 5.5: Better graphics and smooth operation, but coins looked like yellow donuts and required multiple debugging rounds.

Qwen 3.7 Max was the closest to “works out of the box” on the first generation.

Why Qwen 3.7 Max is so strong at long-running tasks

Qwen 3.7 Max isn’t just good at one-shot coding; it’s built as an “agent foundation model” designed for long-term, tool-heavy workflows.

In Alibaba’s internal tests, it:

• Ran autonomously for 35 hours on a programming task
• Executed 1,158 tool calls
• Produced code that achieved a geometric mean speedup over Triton reference implementations
• Maintained zero context degradation, zero instruction drift, and zero infinite loops over the full run

That last point is critical. With modern agent protocols like MCP, calling tools thousands of times in a single workflow is becoming common. Many models start to lose the thread, forget earlier decisions, or fall into loops over long horizons. Qwen 3.7 Max’s ability to stay coherent for 30+ hours is a strong signal that its training focused on stability, not just raw intelligence.

One reported technique is “environment expansion,” where the same programming task is run across different execution frameworks and verification setups (e.g., Claude Code-style environments, OpenAI-style tools, and others). Instead of overfitting to one ecosystem, the model is forced to learn general problem-solving strategies that transfer across tools and platforms.

What this all means for developers and teams

Put together, these developments point to a new phase of the AI coding and research race:

• xAI is betting heavily that real-world coding data plus massive models can close the gap with OpenAI, Anthropic, and Google.
• DeepSeek is showing that near-autonomous research agents can compress weeks of work into days, while also exposing the limits around reliability, novelty, and cost.
• Alibaba’s Qwen 3.7 Max proves that top-tier programming performance is no longer limited to U.S. labs—and that long-horizon, tool-heavy workflows are becoming a core design target.

For developers, this means more choice—but also more fragmentation. Different models are starting to specialize: some as coding agents, some as research partners, some as general-purpose chatbots with massive context windows. The next few months will likely be about testing these systems in your own stack and figuring out which combination actually moves the needle for your workflows, rather than just chasing benchmark scores.