GLM 5.2 vs Opus 4.8 vs GPT 5.5: how good is the new open model really?

GLM 5.2 has been making noise as “the strongest open-source model ever,” with some charts even suggesting it can beat Anthropic’s Opus 4.8 and OpenAI’s GPT 5.5. But benchmarks don’t always tell the full story. How does GLM 5.2 actually perform when you ask it to build things like games and websites—and is it really cheaper in practice?

What GLM 5.2 is (and what it isn’t)

GLM 5.2 is an open-source large language model with almost a trillion parameters. The code and weights are available, which is what people mean when they call it “open source.” But that doesn’t mean you can casually run it on your laptop or drop it into Ollama.

This model needs serious hardware to run. In practice, most people will access it through an API or a hosted provider, just like they do with GPT 5.5 or Opus 4.8. So while it’s open in terms of transparency and self-hosting potential, it’s not a lightweight, consumer-friendly model.

DeepSweep benchmark: why the hype started

A lot of the GLM 5.2 hype comes from a newer benchmark called DeepSweep. DeepSweep is designed to test long-running, agent-style tasks—things like multi-step coding and problem solving—across 113 tasks in TypeScript, Go, Python, JavaScript, and Rust. It runs models in isolated environments and uses program-based verifiers to check if the work is actually correct.

On DeepSweep, each model is scored by:

1) Percentage of tasks solved correctly

2) Average cost per task

The “ideal” region is up and to the right: high accuracy at low cost.

How GLM 5.2 compares on DeepSweep

On DeepSweep, GLM 5.2 Max scores around 44% at about $3.92 per task. At first glance, that sounds solid—until you compare it to Opus 4.8 and GPT 5.5 at more realistic effort levels.

Some key comparisons:

Opus 4.8 (medium effort)

- Accuracy: ~49% vs GLM’s 44%

- Cost: ~$3.44 vs GLM’s $3.92

GPT 5.5 (medium effort)

- Accuracy: ~54% vs GLM’s 44%

- Cost: ~$2.75 vs GLM’s $3.92

At max or extra-high effort, Opus and GPT 5.5 go even further ahead in accuracy—but also get more expensive per task. Still, the important point is that at equal or lower cost, they tend to perform better.

Token prices vs real task costs

On a pure per-token basis, GLM 5.2 is much cheaper:

- GLM 5.2: about $1.40 per million input tokens, $4.40 per million output tokens

- Opus 4.8: roughly 5.7x more expensive per token

- GPT 5.5: roughly 6.8x more expensive per token

But that’s only half the story. In the DeepSweep runs, Opus and GPT 5.5 used far fewer tokens to complete the same tasks. They’re more efficient: they think less, waste fewer tokens, and still get better results.

What really matters is cost per successful task, not cost per token. And on that metric, GLM 5.2 often ends up more expensive for worse results.

There’s another catch: these comparisons use public API pricing. If you’re on something like Anthropic Max or an OpenAI Max plan, your effective cost per token can be dramatically lower than list price. Once you factor in those subsidies, GLM 5.2 loses even more of its cost advantage for individual users.

Real-world test 1: building a 3D browser racing game

Benchmarks are useful, but they don’t always reflect what people actually do. To see how these models behave in a more practical setting, all three were asked to build a playable 3D racing game that runs in the browser.

The prompt was intentionally vague: pick whatever stack and libraries you want, browse the web as needed, and build something playable. Each model first generated a plan, then executed it. Effort levels were chosen to reflect how people typically use these models in coding environments:

- GPT 5.5 Codex on extra high

- GLM 5.2 on extra high via OpenRouter

- Claude Code with Opus 4.8 on high

First pass: basic game quality

Opus 4.8 finished first (about 13 minutes) and used around 100k tokens. It produced a low-poly racing game with smooth controls, basic physics, and a clear track. No AI opponents or fancy visuals, but it worked well and felt coherent—if a bit boring.

GLM 5.2 took about 5 minutes longer and used over 1.3 million tokens, costing around $1.21 for the run. The result: a low-poly track with very jumpy controls, extremely fast movement, and poor separation between the track and the surrounding field. Parts of the track collision were inconsistent, and the car model was less detailed than Opus’s version. It was playable, but noticeably jankier.

GPT 5.5 was the slowest, but used a similar token volume to Opus (around 100k). It produced a night-themed “Foundry Circuit” with odd visual choices: wheels rotating in the wrong direction, very dark lighting, and annoying sound effects. The track worked, but the overall presentation felt strange and less polished than Opus.

Subjectively, Opus 4.8 clearly won the first round. GLM 5.2 and GPT 5.5 both produced functional but awkward games, with GLM using far more tokens to get there.

Second pass: pushing for “triple-A” visuals

All three models were then asked to take a second pass: review their own code, improve the graphics, and aim for something closer to a “triple-A” look.

Opus 4.8 improved significantly with just ~50k more tokens and about 10 minutes of work. The car model looked much better, lighting was upgraded with visible sun reflections and smoother shading, and shadows were added to trees and the environment. Gameplay stayed smooth. While the trees in the road were still a design flaw, visually it was a big step forward.

GLM 5.2 burned another ~1.2 million tokens, bringing the total to about $1.83. The car model improved slightly, and it tried to add more dramatic lighting—but the result was overly bright and glary. The track layout remained confusing, controls were still too twitchy, and some collision issues persisted. In some ways, the visual changes made the game harder to look at rather than better.

GPT 5.5 fixed the wheel issue and slightly improved the car, but the rest of the scene remained largely the same: dark, noisy, and not close to a high-end aesthetic. It didn’t meaningfully elevate the experience compared to its first pass.

Overall, Opus 4.8 stayed comfortably ahead. GLM 5.2 and GPT 5.5 both lagged in polish, and GLM continued to be dramatically less efficient in token usage.

Real-world test 2: designing a smart glasses landing page

Next, the models were asked to build a landing page for a fictional product: AI-powered smart glasses (think Meta Ray-Bans). The instructions:

- Build a fake marketing site for the glasses

- Choose any stack and design approach

- Look up best practices for high-converting landing pages

- Pull in images or product shots from the web if needed

- Make it look like an awards-level site, not generic “AI slop”

Again, GLM 5.2 used around 1 million tokens, while Opus 4.8 and GPT 5.5 used closer to 100k.

First pass: basic landing page quality

Opus 4.8 produced a dark-themed page with a hero section, animated hover effects on the glasses, and scroll-triggered animations. However, some text was cut off, layering was off in places, and the glasses themselves were just HTML/CSS shapes rather than real images. It looked okay, but nowhere near “award-winning.”

GLM 5.2 effectively failed this round. The page barely loaded correctly, layout was broken, and the design felt unfinished and chaotic. Even with a loose prompt, it should have been able to produce a coherent layout—but it didn’t.

GPT 5.5 delivered the best first-pass design. The hero section had a bold layout with a large product visual (though it overlapped text a bit), a moving banner, and a colorful custom cursor. As you scrolled, more sections appeared, but many of the visuals were still HTML-generated rather than real product imagery. It looked the most interesting of the three, but still obviously “AI-generated” to a human designer.

The main takeaway: even top models struggle with high-end visual design without strong, detailed direction. They can scaffold structure and motion, but they don’t reliably hit true “award site” quality on their own.

Second pass: adding 3D with Three.js

For a second round, each model was asked to turn its landing page into an immersive 3D experience using Three.js. The goal: an interactive 3D scene integrated into the site.

Opus 4.8 added a 3D glasses element that moved and reacted to interaction. However, earlier layout issues remained—text still overlapped, and the overall design still looked obviously AI-generated. The hero section improved, but the page as a whole was only “okay.”

GLM 5.2 finally produced a coherent page on the second pass. It integrated a 3D glasses element and a scrolling banner that paused on hover. Layout and structure were better than its first attempt and arguably more consistent than Opus’s full-page design. But the glasses model looked unrealistic, some text was still cut off, and it still didn’t feel like a polished, premium site.

GPT 5.5 came out ahead again. Its Three.js integration fit naturally into the large hero area, with the glasses living in the open white space and moving in a way that matched the rest of the design. The overall page still had that “AI slop” feel to a trained eye, but it was the most visually coherent and intentional of the three.

If you’re interested in more creative build-offs like this, there’s a similar comparison focused on platformer games in Claude Fable 5 vs Opus 4.8 vs GPT‑5.5 Codex, and a broader model overview in GPT 5.5 vs Opus 4.8 vs Gemini 3.5.

Efficiency: GLM 5.2’s biggest weakness

Across both real-world tests, one pattern was impossible to ignore: GLM 5.2 used far more tokens than Opus 4.8 or GPT 5.5 to produce weaker or comparable results.

Examples:

- Racing game: GLM 5.2 used ~1.35M tokens vs ~100k for Opus and GPT 5.5

- Second game pass: GLM burned another ~1.2M tokens for modest or negative visual gains

- Landing page: GLM again hovered around 1M tokens per attempt, while the others stayed near 100k

Even with cheaper per-token pricing, that kind of overconsumption quickly erodes any cost advantage. When you also factor in that Opus and GPT 5.5 are available on heavily subsidized plans for many users, GLM 5.2 often ends up more expensive in practice for worse outcomes.

So, is GLM 5.2 worth using?

GLM 5.2 is an impressive open-source achievement. It’s clearly in the same general capability tier as the top frontier models, which is a big deal for the open ecosystem. But there are some important caveats:

Where GLM 5.2 makes sense

- You care deeply about open weights and self-hosting, and you have the infrastructure to run it.

- You’re optimizing strictly on API list pricing and doing relatively simple or mid-level tasks where its inefficiency doesn’t explode your token usage.

- You’re experimenting or building tooling around open models and want something close to frontier-level behavior.

Where Opus 4.8 or GPT 5.5 are better choices

- You’re on a Max or similar subscription where tokens are heavily subsidized.

- You care about reliability, polish, and efficiency for real products or client work.

- You’re doing long-horizon, agentic tasks where DeepSweep-style performance and token efficiency matter.

In both benchmarks and hands-on tests, GLM 5.2 consistently landed a step below Opus 4.8 and GPT 5.5. It wasn’t catastrophically worse, but it also wasn’t better—and it usually used far more tokens to get there.

Bottom line

GLM 5.2 is a strong open-source model, but it doesn’t dethrone the top proprietary models in real-world use. On complex coding tasks, 3D games, and visually demanding websites, Opus 4.8 and GPT 5.5 still deliver better quality with fewer tokens and, for many users, at a lower effective cost thanks to subscription plans.

If you’re an average individual user choosing a main model for daily work, there isn’t much of a practical argument for GLM 5.2 over Opus 4.8 or GPT 5.5 right now. If you’re an enterprise or a serious open-source enthusiast with the hardware to match, GLM 5.2 is exciting—but it’s not magic, and the hype needs to be balanced with what it actually delivers in practice.