Grok 4.5 Lands as a Fast, Cheap Coding Contender That Closes the Gap with Opus 4.8

Seeing that GPT 5.6 is about to be released, Musk forcefully inserted Grok 4.5, and even went head-to-head with Opus 4.8! I can't hold back anymore!!

Is Grok on the flank really this strong now? My curiosity is exploding, I have to get my hands on it! With foreign models, I can also criticize them without worry, which lets me write more freely.

Besides, while major manufacturers are squeezing out +0.1 increments, Grok has jumped straight to version 4.5, which counts as a major version, so it must be tested!

1. Description and Benchmarks

Before getting started, let's look at the basic info and see how the official description reads:

Today, we released Grok 4.5, SpaceXAI's most intelligent model to date, built to excel at coding, intelligent tasks, and knowledge work. It is our most powerful model yet and was trained together with Cursor.

This is the first paragraph of the entire draft. Built to excel at coding, intelligent tasks, and knowledge work. I've heard this phrase so many times my ears are calloused.

New model releases both domestic and international all say this. GLM 5.2, Doubao 2.1Pro, HY3 almost all use this rhetoric!

Text descriptions are always a bit abstract, so let's look at the benchmark data below:

A total of 5 benchmarks are listed!

Indeed, it surpasses Opus 4.8 on three of them, including Terminal Bench 2.1.

However, on the SWE Bench Pro benchmark, it still falls short of Opus 4.8! The gap is about 5 points, which is still quite significant.

Terminal-Bench 2.1 is a terminal environment task benchmark, mainly checking if an Agent can use the command line to do complex tasks.

SWE-Bench Pro is a professional software engineering task benchmark, mainly checking if a Coding Agent can fix complex problems in a real project.

The record for the SBP benchmark has always been held by Claude, and it is far ahead!

OpenAI has been a bit mentally shaken recently and has started publishing articles questioning the validity of this benchmark!

2. One-Sentence Build

The second part is called "One-Sentence Build"!

The example given is building a 3D solar system with Three.js:

Make a beautiful simulation of the universe and solar system. should be sped up with adjustable time, realistic motion, orbits, stars. use threejs. Make the HUD well styled and conform to modern design principles.

The result image is as follows:

Could Musk have secretly peeked at the examples in my TOPAI? Not to say it's very similar, it's almost exactly the same!

Looking at the official example, the asteroid belt and the star-filled appearance are quite good, with a lot of detail! Musk using this example to show off Grok's muscle is also very fitting, after all, he is a man who wants to take us to "Mars", a man with his heart set on the stars and sea.

3. Fast Speed and Low Price

xAI specifically emphasized the speed issue, saying it can reach up to 80 TPS, placing it in the fast model category!

They also made a special chart called token efficiency. Grok 4.5 significantly leads Opus 4.8!

Musk also confessed on X that the capability is a bit lacking, but most people don't need such a strong model, and we are cheap!

Actually, hearing Musk say this makes me quite sad. The Silicon Valley Iron Man who pursues the extreme can now only seek cost-effectiveness! The large model industry indeed looks a bit difficult; even Musk, a billionaire with millions of fans, is struggling to carry it!

Besides the above content, it probably also talked about some office tasks like making PPTs, and then the specific API price is $2 for input, $6 for output, which is cheap compared to foreign models.

However, this price and speed honestly cannot compare to Xiaomi~~ haha. Wolong has already launched a 1000 TPS model, and other domestic models also have dedicated high-speed models that are much faster than this.

Having said so much, it really comes down to capability. Only after positioning the capability can you talk about cost-effectiveness.

I wanted to try Grok Build a long time ago, but the $300 per month heavy package made me hesitate. Today I heard that X's P membership can also touch it a few times, so I quickly downloaded it to try!

4. Let's Get Grok Build Going!

Grok Build is a terminal agent built specifically for the Grok model. I don't know what the advantages are, but using their own tool with their own model should be the most suitable. If you can't quite understand what this is, just automatically associate it with Claude Code and Codex!

The installation is very simple, just one line of command:

irm https://x.ai/cli/install.ps1 | iex

The installation process is as follows:

Once installation is complete, just type grok or agent to start it.

After starting, you need to log in for authorization. Once authorized, you can use it.

I checked, and indeed the default is already Grok 4.5 (High). And I asked a random question, and it indeed works! I checked the quota, and there is indeed a quota!

I can't wait to run some examples!

5. Hands-on Testing!

Let's first test with the official example, and have it build a 3D solar system for me on the spot.

Directly use the official prompt.

There's a detail in the upper right corner: this is a 500K model, which is an interesting size. The mainstream now has reached 1M. Of course, there are also special players like Tencent Hunyuan 3, whose latest model is 256K!

It took about 4 minutes to finish:

Communicated entirely in Chinese, thumbs up!

It told me the server is running at: http://127.0.0.1:8765

Let me open this address to check:

The effect is roughly like this. At first glance, the sun is about to swallow Mercury!

Other than that, the overall effect is quite good!

For example, this Jupiter has texture, and the same goes for other planets, nice detail!

When I ran Opus 4.8 before, it also had this kind of design!

Textured, and you can click on a planet to zoom in for a close-up view.

Compared to other models I've tested before, Grok 4.5's actual results on this example are indeed quite good!

After testing the official example, let's test my own examples.

Let's start with "Cyberpunk Riverside Scene at Qingming Festival":

Damn, Musk must have seen my website, haha~~ This example is actually not bad, upper-middle level! This example itself is quite special, but I designed it a long time ago, and I suspect many large models have been optimized and trained on it.

Below is the effect from Opus 4.8:

Grok 4.5's image is very clean, drawing the river and boats too, not bad, just slightly fewer elements, slightly fewer Chinese elements, making it feel a bit desolate. Opus 4.8 deliberately put some traditional Chinese characters on the screen to fit the theme, and the layering of the image is better, more delicate.

Grok 4.5 drawing the river and boats gets a thumbs up!

The key point is, it only took over two minutes, with no verification, completing everything in sequence. Unlike some domestic models that run for a long time generating, then desperately verify, burning tokens like crazy! Using verification to make up for capability deficiencies.

Next, let's test a game, let it make a "Super Mario".

The prompt is exactly the same as our previous tests.

This time, it also finished very quickly, but unlike before, this time it started verifying!

This wave is impressive; it called the browser and started playing by itself.

Playing while modifying the code. I watched while eating melon. Its first version had a problem with jumping; it couldn't jump high. Luckily, it detected and fixed this problem itself.

This time it took a total of 9 minutes, longer than the previous example, but much better than the players that start at 40 minutes!

Below is its summary.

Implemented Content

• Classic 1-1 style level: ground, pits, pipes, bricks, question blocks, stairs, flagpole, castle • Physics: gravity, variable jumping, coyote time, walkable steps • Enemies: Goomba (stompable, touching causes damage/death) • Items: coins, mushroom growth (big Mario can break bricks) • HUD: score, coins, world, time, lives • Flow: fall into pit / get hit / timeout death → lose life and respawn; touch flagpole and slide down → walk into castle to clear level

Self-Test Results

Verified: hitting bricks for coins, mushroom growth, stomping enemies for points, flagpole clearing, no obvious JS errors.

Happy clearing! If you want to add sound effects, a second level, or mobile virtual buttons, just say so.

Simple and clear, I like this style! The final result is also good:

Restoration and playability are both decent! It can be cleared smoothly!

Below is the effect from Opus 4.8:

Coincidentally, their results, overall feel, are somewhat similar. Grok 4.5 couldn't have distilled Opus 4.8, right? It feels like it's going head-to-head. Of course, Super Mario originally looks like this, maybe different paths lead to the same destination!

I also had it test a round of "Battle City"!

This time was strange; the browser call failed during verification, even though it played smoothly in the previous round!

Then the result looked roughly like this:

This round is playable, but very difficult to play. The details aren't great; the map, movement trajectory, and wall-hitting logic all have some problems, roughly on par with the first-round results of domestic models.

I've been testing the above examples for a while now, so let's move on to a relatively new example.

Astronomical Mechanical Watch:

Use a single HTML file to implement an astronomical clock in the style of a mechanical wristwatch, purely native implementation, no libraries, frameworks, or CDNs allowed. Requirements:
​
1. The main dial reads the local system time, the second hand sweeps smoothly, driven by requestAnimationFrame, and must not accumulate drift over long runs; when switching to another tab and back, the hands must immediately calibrate to the correct time.
​
2. Include a moon phase sub-dial, calculating and displaying the continuous change of the moon phase based on the current date. The formula needs to be self-implemented, with accuracy error controlled within 1 day.
​
3. Include a usable chronograph, displayed via sub-dial hands, supporting start, pause, continue, reset, and lap. Buttons must not cause state errors when clicked in any order.
​
4. A date window displays the current date, correctly handling short/long months and leap years.
​
5. Include a day/night / sunrise/sunset indicator. Users can switch between three to four preset cities, and the local sunrise/sunset times are calculated on the spot based on latitude and longitude.
​
6. The page needs to be responsive and respect prefers-reduced-motion: when enabled, the second hand switches to ticking and decorative animations are turned off; also add ARIA labels for each dial.
​
7. The overall visual should look like a real high-end wristwatch, not an ordinary practice assignment.
​
Only output the final code, no explanation.

On this example, most models currently perform poorly, basically all having some issues. Only Claude's strongest model can get it right in one go without major problems. The difficulty of this problem lies in stuffing many requirements at once, all requiring some thought, which scatters the AI's attention and causes it to make mistakes in details.

Grok, this time, again acted like a handsome man who fires a shot and never looks back. Finished in one round, no checking!

This design is quite good, thumbs up.

Then the main large clock is normal, the stopwatch and lap are normal, the moon phase is normal, and it includes sunrise/sunset for four regions. These are all good.

But the design of the four small sub-dials on top is not great. It used three small sub-dials for the stopwatch, which is too exaggerated. Normally, one or two sub-dials are enough for stopwatch timing, after all, it's just a stopwatch. Also, its date window blocked the stopwatch dial. And when selecting a region, it didn't mark sunrise and sunset on the small dial. The moon phase proportion should be correct, but it lacks curvature.

Overall, the general direction is okay, but the details have room for optimization. This example ranks in the upper-middle position.

I really like this style!

I also tried having it run 9 examples at once:

It only took over 9 minutes, and in the end, all examples had no basic errors. This point already beats many models.

It feels like Grok 4.5 has stood up!

You have to know that grok-4.20's front-end score on the arena was ranked in the 50s. This time's 4.5 is clearly much, much better. The strange thing is that the arena refreshes domestic model scores every time, but this time there's no score for grok 4.5!

First experience, Grok 4.5 indeed has something. Before, because its performance was too poor, I never let it sit at the table. This time, as soon as it sat down, it spoke with elegance. Haha!

Musk can hold his head high 😄! The benchmark data should be basically accurate!

If the benchmarks are accurate, then it's estimated that Grok mainly lags behind Opus 4.8 on complex programming projects, while on relatively simple parts, it won't be much worse.

Grok 4.5's overall coding efficiency is very high, the total cost should be relatively low, and the results are also good. It's worth keeping an eye on and getting to know better in the future!

Tomorrow I will update the relevant examples to: https://topai.jarvisuni.com/

You can view and compare intuitively. Currently, there are already over a dozen models for reference!