How to use GLM 5.2 in Claude Code (and when it actually beats Opus)

Open-source models are catching up fast, and GLM 5.2 is one of the clearest examples of that shift. It’s huge, surprisingly capable, and when you plug it into Claude Code, it can handle a lot of your day-to-day work at a fraction of the price of top closed models like Opus.

This guide breaks down what GLM 5.2 is, how it compares to Claude Opus in real use, when you should actually use it, and how to wire it into Claude Code using Z.ai.

What GLM 5.2 actually is

GLM 5.2 is a massive open-source language model (around 750B+ parameters) with a 1M-token context window. Because it’s open source, you’re not just renting access to a black box—you can, in theory, run it yourself if you have the hardware.

In practice, almost nobody has the infrastructure to run a 700B+ parameter model locally. That’s where services like Z.ai come in: they host GLM 5.2 in the cloud and expose it via an API, similar to how you access Claude or GPT models, but at much lower per-token prices.

How GLM 5.2 feels inside Claude Code

When wired into Claude Code, GLM 5.2 behaves like any other Claude-compatible model: it can use the harness, read your cloud.md, call skills, and run /goal workflows. The big difference is cost and, depending on the task, speed.

In real-world testing, GLM 5.2 was used to:

• Edit a video intro from raw footage to final script in a single /goal run
• Design full landing pages from one-shot prompts
• Complete structured homework-style coding and data tasks
• Run multi-agent research workflows using custom skills

It’s not perfect, and it’s not always faster than Opus, but for a huge chunk of everyday work, it’s more than “good enough”—especially at its price point.

GLM 5.2 vs Claude Opus: real examples

The most useful comparison isn’t a benchmark chart—it’s seeing how both models behave on the same tasks. Here are a few concrete side-by-side tests.

1. One-shot landing page design

Both GLM 5.2 and Opus were given a single prompt to design a branded landing page. The results looked surprisingly similar in quality and structure: consistent branding, dynamic elements, and clear calls-to-action.

The main differences were under the hood:

• GLM 5.2: finished in about 4 minutes, used fewer tokens, and cost ~5x less per token.
• Opus: took about 15 minutes for a comparable result.

From a pure design and UX perspective, the gap wasn’t remotely 5x in Opus’s favor, even though that’s roughly the price difference.

2. Structured homework-style task

Both models were given the same “homework assignment” generated by a separate agent to avoid bias, then judged by another model. The judge preferred Opus because it caught a subtle edge case: handling duplicate records with values like true vs 1 vs 1.0.

Takeaways:

• GLM 5.2 was solid and mostly correct.
• Opus was more precise on tricky reasoning and edge cases.

This lines up with the broader pattern: GLM 5.2 is excellent for broad, high-volume knowledge work; Opus still wins when deep, careful reasoning really matters.

3. Creative one-shot HTML experiences

Both models were asked to “get creative” and output any HTML experience they wanted.

• GLM 5.2 created an interactive page called “The Anatomy of Attention,” with animated stars, relationship graphs between tokens in a sentence, and explanatory sections about how language models understand context.
• Opus produced “The Life of a Death Star,” a timeline-style interactive page with its own distinct visual style.

Again, both outputs were strong. Opus finished this task in about 11 minutes; GLM 5.2 took around 35 minutes. So while GLM 5.2 can absolutely do creative front-end work, its speed depends heavily on how reasoning-heavy the task is.

Where GLM 5.2 shines (and where Opus still wins)

Based on extended testing, a useful mental model is:

• GLM 5.2: great for 70–80% of everyday knowledge work—design, content, research, coding that isn’t packed with tricky edge cases.
• Opus 4.8: better for the remaining 20–30%—deep reasoning, complex tradeoffs, subtle logic, and high-stakes decisions.

In other words, you probably don’t need Opus-level power for most of your day. The real skill going forward is choosing the right model per step of your workflow, not defaulting to the “biggest” one every time.

For example:

• Use GLM 5.2 to gather information, summarize sources, generate drafts, and explore design ideas.
• Use Opus to interpret that information, stress-test assumptions, and help decide what actually matters and how to apply it.

This multi-model mindset is already becoming standard in serious AI workflows, especially in agent-style setups. If you’re interested in that space, it’s worth also looking at tools that support agents and orchestration, like those covered in this deep dive on GPT-5.4 for coding and agents.

Why open-source models like GLM 5.2 matter

Closed models like Claude and GPT are powerful, but you’re renting them. As the Fable model saga showed, access can be changed or removed overnight. On top of that, many providers are not yet profitable, even when users get thousands of dollars’ worth of inference for a flat monthly fee.

Open-source models change that equation:

• You can host them yourself if you have the hardware.
• You can run them through cheaper third-party providers.
• You’re less exposed to sudden product or pricing changes.

GLM 5.2 is especially interesting because it’s competitive with frontier models on many benchmarks while being dramatically cheaper to run via services like Z.ai. On some coding and reasoning benchmarks, it even edges out models like GPT 5.5 or earlier Claude releases, at least on paper.

Benchmarks aren’t everything, but they reinforce what you can feel in practice: this model is genuinely in the same league as top closed models for many tasks.

Pricing: how much cheaper is GLM 5.2 really?

Using Z.ai’s hosted GLM 5.2, the rough pricing comparison looks like this:

• Opus 4.8: around $5 per million input tokens, $25 per million output tokens.
• GLM 5.2: around $1.40 per million input tokens, $4.40 per million output tokens.

That’s roughly a 5x difference in cost for the same token volume. For a heavy day of coding or design work, that adds up fast.

Z.ai offers both pay-per-token billing and subscription plans (e.g., around $16, $64, or $144 per month, with discounts for yearly billing). Subscriptions give you a time-based quota, similar to Claude Code’s usage model, with separate limits for total hours and web search.

How to access GLM 5.2 through Z.ai

To use GLM 5.2 without running it locally, you can connect through Z.ai’s cloud API.

1. Create a Z.ai account and explore the UI

After signing up at Z.ai, you’ll land in a playground where you can:

• Chat with GLM 5.2 directly
• Generate landing pages
• Build simple 3D models or mini games

This is a good way to get a feel for the model’s strengths, especially in front-end and creative tasks.

2. Choose billing: pay-per-token or subscription

In the billing section, you can either:

• Use pay-per-token pricing based on the per-million token rates, or
• Pick a subscription plan that gives you a monthly time quota (with higher consumption during peak hours and separate web search limits).

For serious daily use alongside Claude, a common pattern is to keep a Claude subscription for Opus and a mid-tier Z.ai plan for GLM 5.2, then switch between them depending on the task.

3. Generate an API key

Once you’ve chosen a billing option:

• Go to the API section in Z.ai.
• Create a new API key.
• Copy it—you’ll paste this into your Claude Code configuration.

Connecting GLM 5.2 to Claude Code

Claude Code acts as a harness: it orchestrates tools, skills, and context, while the underlying model is the “engine.” To swap in GLM 5.2, you just point the harness at Z.ai instead of Anthropic’s API.

1. Locate your Claude Code settings file

Inside your Claude Code project, you should have a file named settings.local.json. This is where you configure:

• Permissions
• MCP servers
• Environment variables (including API keys and base URLs)

If you’re using agent teams or multiple projects, this file might live at the project level or globally, but the idea is the same.

2. Add environment variables for Z.ai

In settings.local.json, you’ll define environment variables that:

• Set the Anthropic base URL to Z.ai’s API endpoint.
• Set the Anthropic API key value to your Z.ai API key.
• Change the default model names to glm-5.2 (or the exact identifier Z.ai uses).

The pattern looks like this conceptually:

• ANTHROPIC_BASE_URL → Z.ai’s GLM 5.2 endpoint
• ANTHROPIC_API_KEY (or similar) → your Z.ai key
• Default model fields → glm-5.2 with 1M context

You can even ask Claude Code itself to update settings.local.json for you by pasting a template and saying, “Apply this to my local settings,” then just swap in your actual API key.

3. Verify GLM 5.2 is active

After saving the config, open Claude Code in that project directory. At the top of the interface, you should now see something like:

GLM 5.2 • 1M context • API usage billing

At this point, Claude Code is using GLM 5.2 as the engine, but all your usual workflows—/goal, skills, cloud.md, and agents—still work as before.

Using different models per project

One nice trick is to keep separate project folders, each wired to a different model setup. For example:

• /projects/glm/ → has a settings.local.json that routes to GLM 5.2 via Z.ai.
• /projects/opus/ → no special settings file, so it defaults to your Claude Max plan with Opus.

Open Claude Code in the GLM folder, and you’re on GLM 5.2. Open it in the Opus folder, and you’re back to Anthropic’s default stack. This makes A/B testing and model selection per project very straightforward.

Multi-agent research with GLM 5.2

One of the strongest use cases for GLM 5.2 inside Claude Code is multi-agent research. For example, you can create a /goal that:

• Uses a custom “storm research” skill.
• Spawns multiple sub-agents with different personas (e.g., academic, skeptic, practitioner, economist, historian).
• Has one pass generate a full HTML report, then another pass review and refine it.

The result in testing was a long-form HTML report on open-source vs closed-source AI models, complete with:

• A 60-second summary
• Key findings with notes on which personas supported or challenged each point
• Hidden assumptions and practical recommendations

In this kind of setup, the orchestration—the way agents are designed, how they critique each other, and how the workflow is structured—matters more than squeezing out a few extra IQ points from the underlying model. GLM 5.2 is more than capable enough to power this style of research.

The bigger picture: a multi-model future

The gap between closed and open models is shrinking fast. It’s easy to imagine a near future where most companies run their own local or self-hosted models for the bulk of their work, and only call out to closed providers for specific, high-value tasks.

Vendors like Anthropic and OpenAI seem to recognize this, which is why they’re investing heavily in services, integrations, and higher-level offerings beyond just “here’s an API.” The core model itself is becoming less of a moat as open-source catches up.

For individual users and teams, the winning strategy is clear:

• Learn to work with multiple models.
• Use open-source where it’s “good enough” and much cheaper.
• Reserve frontier closed models for the hardest reasoning and highest-stakes decisions.

If you’re already deep into Claude Code, GLM 5.2 is one of the easiest and most impactful upgrades you can experiment with. And if you’re exploring broader coding and agent workflows, it pairs nicely with the kinds of setups described in this guide to Claude Code tools for vibe coding.

The bottom line: GLM 5.2 won’t replace Opus for everything, but it can absolutely handle most of your daily workload—while saving you a lot of money and giving you a taste of what a more open, multi-model AI stack looks like.