Zhipu ZCode 3.0 Launches: Bringing Claude Code to the Desktop

In mid-June, Zhipu quietly pushed ZCode to version 3.0. This update really only carries two key messages: it switched to the self-developed ZCode Agent core and deeply integrated with GLM-5.2. In other words—the old ZCode, which felt more like a “multi-CLI aggregator,” is finally starting to grow its own skeleton, and it’s now much more tightly bound to Zhipu’s flagship coding model.

If you haven’t been following this product line closely, here’s a quick recap: ZCode first launched as an Alpha version alongside GLM-5 on December 26, 2025; after GLM-5 went open source in February this year, interest surged and ZCode evolved along with it; then on June 13, version 3.0 was officially announced. Three major leaps in half a year is an aggressive pace by domestic AI coding tool standards.

One-line positioning: A GUI shell for Claude Code, and more than just one Agent

The slogan on the official site zcode.z.ai is very direct — “Claude Code from the Makers of GLM.” It’s a bit clever. It doesn’t claim to be a replacement for Claude Code; instead, it implies: “We built something similar, but from the GLM team.”

In reality, the product form is quite different from Claude Code. Claude Code is pure CLI, everything runs in the terminal; ZCode is a cross-platform desktop application (Mac / Windows) that wraps CLI Agent capabilities inside a GUI. You can think of it as: Cursor’s interface structure + Claude Code’s Agent execution paradigm + a unified API key entry point.

More accurately, ZCode is an “AI Agent container.” It natively integrates CLI Agents from three companies:

• Claude Code (Anthropic)
• Codex (OpenAI)
• Gemini CLI (Google)
• And its own ZCode Agent (the new self-developed core in 3.0)

With one key, switching models is just a click on “SelectModel” in the chat box. For developers constantly hopping across subscriptions, the value of this experience speaks for itself.

The biggest change in 3.0: a self-developed Agent core

From versions 1.x to 2.x, ZCode was essentially a “wrapper project” — taking other companies’ CLI Agents, packaging them in a GUI, then adding desktop-level features like session management, permission confirmation, and Git integration. But wrapper projects have a ceiling: you can’t control the Agent’s reasoning strategy, optimize context scheduling, or deeply tune for a specific model.

After switching to the self-developed ZCode Agent core in 3.0, the trajectory changed. Zhipu can now:

1. Redesign tool invocation workflows around the capability boundaries of GLM-5.2
2. Fully control implementations of planning, reflection, and self-correction
3. Integrate MCP (Multi-Agent Collaboration Protocol) as a first-class citizen

This is actually a step every domestic coding-tool company has to take — you can’t live forever on top of someone else’s Agent, because even the strongest model won’t fully realize its potential that way. It’s similar to how Cursor initially relied on tuning GPT-4, but later had to build things like Cursor Tab and Composer to create defensibility.

GLM-5.2 integration: coding ability is the key variable

ZCode 3.0 is deeply optimized for GLM-5.2. This model wasn’t released together with the open-source GLM-5 in February; it’s a version Zhipu specially post-trained for coding scenarios. Based on community feedback, GLM-5.2 can already compete in the same tier as Claude Sonnet on benchmarks like SWE-bench Verified and LiveCodeBench — though benchmarks are benchmarks, and real-world performance still depends on stability under long-context workloads.

I personally tested several scenarios with ZCode 3.0 + GLM-5.2:

• Refactoring a medium-sized React component tree: logic decomposition was reasonable, but sensitivity to side effects in legacy code was weaker than Claude Code + Sonnet 4.5
• Adding an asynchronous task queue to a Python FastAPI project: completed successfully in one pass, with proper MCP invocation patterns
• Adjusting frontend CSS details: took several rounds before aligning properly; to be fair, most tools struggle in this scenario

Overall, my conclusion on GLM-5.2 inside ZCode is: it has reached mainstream standards for everyday coding tasks; there’s still a gap in complex refactoring and debugging scenarios, but the pricing advantage more than compensates. The GLM Coding Plan subscription is dramatically cheaper than Claude Pro. If most of your work is CRUD, scripts, or utility development, the cost-performance curve is extremely attractive.

Conversation as workflow: ZCode’s product philosophy

ZCode has several design details worth highlighting. They aren’t copies of Claude Code — they clearly target pain points that only emerge after prolonged CLI use.

Explicit file inclusion

You must @-mention files in the conversation for the Agent to include them in context. This design is already standard in Cursor, but CLI Agents usually rely on the model guessing — and when it guesses wrong, it may modify a pile of unrelated files. ZCode enforces explicit inclusion, giving context control back to developers.

Permission model first

Any operation that modifies the filesystem or executes shell commands requires user confirmation. You can choose “Allow this time,” “Always allow this type of operation,” or “Deny.” This is the opposite of Claude Code’s --dangerously-skip-permissions logic — ZCode locks permissions down by default, while Claude Code opens them by default and leaves it to users to restrict them. Which approach is better depends on preference, but for team development I lean toward ZCode’s philosophy.

Editable conversation history

This is probably my favorite feature in ZCode. In traditional CLI Agents, if your prompt goes off track, you usually have to roll everything back and start over; ZCode lets you directly edit a message in the conversation history and branch execution again from that point. It’s basically bringing the concept of git rebase to the prompt layer.

Using pseudocode to describe the interaction:

Conversation history:
[msg 1] User: Help me implement a rate limiter
[msg 2] Assistant: Sure, I'll use a token bucket...
[msg 3] User: Change it to sliding window

// Now you realize msg 3 should be more detailed
// Directly edit msg 3 -> "Change it to sliding window, use Redis for storage, and consider distributed scenarios"
// ZCode re-executes from msg 3, regenerating msg 4 and everything after

This capability is extremely important for complex tasks — you don’t need to restate the context of the previous 30 steps, only fix the one step that was actually wrong.

Thinking mode

ZCode lets users explicitly control whether the Agent enters “deep thinking” mode. When enabled, the Agent first performs planning, task decomposition, and self-review before acting; when disabled, it executes directly. This toggle maps neatly to task complexity: turn it off for writing a regex, turn it on for architecture-level refactoring.

Mobile remote control for desktop

Version 3.0 also strengthens a relatively uncommon capability — the mobile app can remotely direct the desktop Agent to work. You can attend a meeting while the Agent runs a long task on your office machine, checking progress and sending instructions from your phone. It sounds a bit geeky, but for developers frequently running long-duration tasks (like large-scale refactoring or data migration scripts), it genuinely solves a real problem.

MCP is the setup for what’s next

ZCode 3.0 explicitly supports MCP (Model Context Protocol). This means you can plug in your own tools, internal APIs, and database interfaces for the Agent to invoke directly. This is especially critical for enterprise users — many companies don’t lack AI coding tools; they lack one that can connect to their internal infrastructure.

The MCP ecosystem is gaining momentum this year overall. Claude Code, Cursor, and Windsurf are all moving in this direction. ZCode’s early push into MCP is both defense and offense.

So which is better: ZCode or Claude Code?

This is the question everyone asks, and here’s the answer that doesn’t try to please either side:

• Pure coding ability and Agent intelligence: Claude Code + Sonnet 4.5 is still the ceiling
• Visualization and team collaboration friendliness: ZCode is clearly better
• Pricing: ZCode wins decisively, especially with the GLM Coding Plan
• Multi-model flexibility: a unique ZCode advantage — one key switches among three ecosystems
• CLI power-user experience: Claude Code is irreplaceable; pipelines and scripting are its territory

So the real choice isn’t one or the other. The most reasonable setup I’ve seen is: use ZCode for daily development (because of visualization and multi-model switching), and Claude Code CLI for critical tasks and automation scripts. Each tool excels in its own scenarios.

Some unresolved issues

To be fair, ZCode 3.0 still has its flaws:

1. The jump from Alpha to 3.0 happened too quickly, and stability is still being polished. The right-side code panel currently only supports previewing, not manual editing, which is a major drawback for users accustomed to IDEs
2. Some interaction bugs remain, such as certain files not responding in the right-side panel after being clicked
3. There’s still no sign of a Linux version, which is unfriendly to server-side developers
4. Chinese documentation is comprehensive, but the English-language community is nearly nonexistent, limiting overseas adoption

These are normal early-stage product issues, but now that it has reached 3.0, polishing needs to become a higher priority.

One more thing

If you want to directly use the GLM-5.2 API for your own Agent integrations, OpenAI Hub already supports the model. It’s compatible with the OpenAI format, and one key can simultaneously access Claude and Gemini as well. This is ideal for developers who want to build their own workflows without being locked into a single desktop client.

Final thoughts

ZCode’s ambition is actually very clear — it doesn’t just want to be a companion tool for GLM; it wants to become the default AI coding entry point for Chinese developers. Version 3.0’s switch to a self-developed core and tight integration with GLM-5.2 is the first concrete step toward that ambition.

From an industry perspective, the AI coding tools space will become even more competitive in 2026. Cursor has first-mover advantage and strong product execution, Claude Code has the strongest model capabilities, Windsurf focuses on enterprise markets, and ZCode is betting on the differentiated combination of “multi-model + desktop-first + low price.” Who ultimately wins will depend on whether model capabilities and product experience can evolve together.

At ZCode’s current level of maturity, my assessment is: it’s worth downloading and using as one of your primary tools; but if you heavily rely on the power-user capabilities of Claude Code CLI, it still can’t fully replace it in the short term.

References

• Zhipu AI coding tool ZCode 3.0 released: switches to self-developed ZCode Agent core, deeply optimized for GLM-5.2 - IT Home — Official report on the 3.0 release
• Zhipu quietly releases ZCode, making Claude Code easy to use visually - Zhihu Column — Overview of ZCode’s early positioning and features