Grok 4.7 Hands-On Review: Why Musk's Hyped Model Falls Short

Grok 4.7 is finally here. This is a model Musk has been hyping for over a month — back when 4.5 launched, he declared that 4.7 would be the "big one," surpassing every existing model, and even claimed that thanks to SpaceX's unique training data, "no model will be able to beat Grok 4.7 on real-world coding."

The irony is that this much-anticipated model actually scores lower than Grok 4.6 on several benchmarks. The core of this piece isn't a simple cheerleading or hit piece on a new model — it's about a more important issue: benchmarks are increasingly failing to reflect real-world experience, and the volume of misleading data xAI published around this launch is genuinely frustrating.

One caveat upfront: despite all the criticism, Grok 4.7 is actually one of my favorite models to use this year.

The Gap Between Official Claims and Reality

Grok 4.7 is officially positioned as "the most capable model for coding and knowledge work": it works harder on difficult tasks, checks its work more carefully, comes with the best safety guardrails to date, and is priced and speeded identically to Grok 4.6.

The problem lies in the "same price, same speed" claim. Musk had previously made an explicit promise: Grok 4.6 is a 1.5 trillion parameter model, while 4.7 would be a brand-new 2.1 trillion parameter base, "superior to 4.6 in every way, only slightly slower in serving speed, but with better token efficiency."

The real numbers tell a different story. According to Artificial Analysis testing, Grok 4.6 consumes roughly 38k tokens per task at the MXX High tier, while Grok 4.7 spikes to 81k tokens — even exceeding Fable 5.1. The claim of "better token efficiency" simply doesn't hold up.

Interestingly, Cursor's CEO and co-founder Michael Truell (now deeply involved with xAI, since Cursor and xAI are now the same company) publicly pushed back on the cost-doubling narrative, stating that in SpaceX and Cursor production environments, 4.7 uses only 5% more tokens on median requests and 20–30% more on p99 requests.

The Critical Distinction: Requests vs. Prompts

At the heart of this debate is the difference between a "request" and a "prompt."

Measuring token consumption by request count is inaccurate. A single prompt can trigger wildly different numbers of requests: if I send "reply hello," the model only needs one request; but if a task requires extensive tool calls, each tool call generates a new request.

So Michael's claim might be valid on the "single-request token increase of 20–30%" dimension, but if the number of requests per prompt is itself rising (which it is), then the per-request increase becomes irrelevant. When benchmarks like Artificial Analysis — which are increasingly skewing toward agentic workloads — run their tests, each prompt likely triggers more requests, which compound into much higher costs.

Real usage data backs up the cost concerns: running the same benchmark suite, Grok 4.6 cost $1.86, Astra cost $3.26, and Grok 4.7 came in at $3.74 per task. Across a full test run, this adds up to thousands of dollars.

This distinction matters especially in agentic workflows. Traditional LLM calls are single-turn "question and answer" — one prompt, one API request. In agentic mode, the model is given the ability to call external tools (search, code execution, file I/O), and each tool call triggers a new round of context assembly and model inference, forming a "request chain." Take a simple coding task: the model might read a file (1 request), generate code (1), run tests (1), read error logs (1), then fix the code (1) — one prompt ends up triggering five or more requests. Using "per-request token increase" to measure actual costs in agentic scenarios systematically underestimates real expenditure. Benchmarks like Artificial Analysis are migrating toward agentic workloads precisely because such tasks better reflect how models operate in real production environments, rather than isolated Q&A.

Cherry-Picked Benchmarks

The benchmark selection in the official blog post is quite telling. On Cursor Bench, Grok 4.7 performs well, beating GPT-5.6 Sol on nearly every tier at better price-to-performance. But Astra is notably absent — because OpenAI has banned xAI from using its models, making that comparison impossible to include.

On EE Bench (electrical engineering), Grok 4.7 is genuinely world-class — credit where it's due. But overall, this is an unusually sparse and clearly hand-picked benchmark set. On Terminal Bench, Fable 5.1 scores a full 20 points higher — nearly a 50% improvement. And then there are counterintuitive results like "Grok 4.6 beats GPT-6 Astra" on GDP Val that strain credulity.

The straightforward assessment: benchmarks simply cannot accurately capture this model's real strengths and weaknesses.

"Cherry-picking" in AI evaluation refers to vendors selectively showcasing benchmarks favorable to their model while omitting results where it underperforms. This practice is extremely common in the industry, though transparency varies widely by vendor. Cursor Bench, Terminal Bench, GDP Val, and EE Bench are all domain-specific or task-specific benchmarks, each with a different focus: Cursor Bench emphasizes code completion within an IDE, Terminal Bench is closer to system-level command-line operations, and EE Bench focuses on electrical engineering knowledge. A high score on any single benchmark only indicates capability on that specific task type — it does not support a conclusion of "overall best." When an official evaluation report presents only a handful of benchmarks with no systematic relationship between them, it typically signals that a large number of less flattering comparisons were intentionally omitted.

Pricing Is the Real Pain Point

What makes this launch truly difficult to accept is the pricing strategy.

Podcast co-host Ben Davis is a hardcore Grok fan — a Grok Code Fast devotee and heavy Grok Build user. Even he called the pricing overly aggressive. While the default token price shown is identical to 4.6, the cost doubles beyond 200k tokens, and fast mode adds another surcharge on top, making normal usage feel terrible.

The concrete math: Ben burned through 8% of his weekly allocation in $40 of usage. That means on a $300/month plan, you don't get much per week — while other labs' $200/month plans often provide the equivalent of $8,000–$12,000 in monthly usage.

Grok's biggest selling point used to be near-unlimited usage under its large subscription plans. That advantage is now gone. And what you're getting in return isn't the "premium tokens" of Fable or Astra — it's a model closer to Sol and Opus tier, now saddled with strict quota limits.

Weird Behavior From Training Adjustments

The model was originally planned for release last week but got delayed. Musk revealed why: the RL phase may have over-penalized response length, causing the model to give up too early on hard tasks and not check its work rigorously enough. The team spent about a week using RL to correct this, making the model more willing to do long-running work and verify results — which is very likely why the token efficiency disappeared.

The side effects have been bizarre. Users in Grok Build have seen the model fall into strange loops, repeatedly outputting things like "I am infinite superintelligence," "I am a rendering scientist," "I'm ready at all times, I'm building" — in an infinite loop. This weirdness has even leaked into unrelated places like X's translation button, where it has no business appearing.

The RL (reinforcement learning) phase in model training comes after pretraining and supervised fine-tuning, using reward signals to further shape model behavior — RLHF (Reinforcement Learning from Human Feedback) and RLAIF (Reinforcement Learning from AI Feedback) both fall under this category. The RL phase is extremely sensitive to reward function design: if the reward over-penalizes output length, the model will tend toward short but sloppy answers; if it over-rewards verbosity, "reward hacking" emerges — the model learns to pile up tokens through repetition or meaningless output to score higher. The "giving up too early on hard tasks" Musk described is a textbook symptom of the former problem, while the infinite loops appearing after the fix may be an overcorrection causing the model to enter an anomalous reward-maximizing state under certain triggers. Side effects from late-stage training adjustments like this typically require multiple iterations to stabilize, and are especially common right after a model launches.

A Custom Benchmark and a Frontend Disaster

A new benchmark was improvised for this review: asking different models to analyze the T3 Code codebase and identify areas for improvement.

The results were surprisingly valuable: Astra came out on top, finding the most novel and well-substantiated improvement points; Grok 4.7 followed closely in second, performing quite well; Fable 5.1 only offered 5 suggestions (compared to 8 from other models), but the quality was high. Grok 4.7 and GPT-6 Astra were noticeably more thorough in their depth, even catching issues that Fable and Astra missed.

But cost remains a hard blocker: Grok 4.7 is roughly equivalent to Astra and Fable in the best case, and up to twice as expensive in the worst case.

On the famous "fish slop" frontend test, the results were disastrous: mouse tracking speed was completely wrong, cursor position was erratic, the submarine rendering was meme-level bad, and the fish animation directions were all reversed. With the same prompt and same environment, Astra produced a respectable game; Grok 4.7's output was "the worst frontend I've seen in recent memory." The run was also unusually slow — the fish slop build took nearly an hour and a half.

Verdict: A Transitional Stepping Stone

Taking everything together, Grok 4.7 is a contradictory model. It's more pleasant to interact with, has a higher floor in real work, and sustains focus on tasks better — these are genuine strengths. But the performance leap is nowhere near enough to justify the cost leap.

Right now it's more expensive, slower, more error-prone, and produces worse code, while the speed and economy that made Grok worth choosing — especially Grok 4.5's efficient, cheap, and fast character — are entirely absent in 4.7. Compared to the genuine generational leaps that Fable and Astra represent, Grok 4.7 is still stuck in the previous tier.

The verdict: this is a stepping stone, nothing more. If you're already locked into Cursor as your primary inference source, it's worth trying; beyond that, it's hard to recommend. Hopefully the next model will actually deliver on Musk's promises — frontier performance at a meaningfully better price. For now, what we have is "last-generation performance at current-generation prices," and that's not a trade-off that makes sense.