Z.ai's GLM 5.2 is a great model, but is it good value?

Last month Zhipu AI released a new model: GLM-5.2: Built for Long-Horizon Tasks

Since then, it has climbed most of the open model coding oriented leaderboards and now sits at the top, also closely trailing Anthropic's Opus models:

This caught my attention, because personally I enjoy the capabilities of Opus, but don't enjoy its tone.

I am currently on their Max 5x plan for about 108 EUR per month, so looking into whether there are any other more cost effective options or subscriptions feels like a good idea. For example, I explored using the DeepSeek API billing and while it is pretty affordable, sadly the performance wasn't quite there, whereas hearing about a near-SOTA model is really promising!

I will admit that I also need something that provides me with a lot of tokens, maybe a bit more than the average developer dabbling in using LLMs, here's how my Anthropic plan limits start to look at the end of the week, this time made a bit worse cause I used Fable while I still could:

It's not that I'm necessarily without fault, sometimes I can be wasteful with tokens. At the same time, when I need a large scale exploratory task to plan things correctly and not have to rewrite everything a week later (essentially what Barry W. Boehm said about defects being easier to fix early on in the development), I think it makes a lot of sense to just swallow those costs and get it over with:

With that in mind, I decided to give Z.ai and their GLM a quick look, to see:

• whether the model is good enough for daily driving and agentic development
• whether their token limits make sense for how I work

You can find the details of their subscription here: GLM Coding Plan

Overall, the signup was pretty similar to the other providers out there, except you get an API key and aren't locked into something like Claude Code. That is nice to see, they support multiple coding agents out of the box as you'd expect with that setup, so running with OpenCode or anything like that isn't a problem.

So far so good, I didn't see any real red flags. Some might dislike the fact that it's a Chinese company, but to be honest most good open models come from China at this point. In addition, I generally like to test out the first party providers, to not get misdirected by some 3rd party provider sneakily running quantized versions that would perform worse (Zhipu AI could at some point run quantized versions of their own model, but then any bad impressions would at least be the "canonical" experience).

Regardless, I was curious but didn't want to commit fully, so I first went for their Pro plan, which in practice charged me 57 EUR, or just over half of what my Anthropic monthly subscription costs me:

Both their offering and Anthropic's say that it's 5x the usage of the regular plan, though obviously that says almost nothing about how many tokens that gets you, exactly (especially because peak and off-peak load times are charged differently), nor does it tell you how many tokens either model realistically needs to complete a given task.

Doing custom harnesses right

While Z.ai also doesn't lock you into a particular harness, they also seem to have a limited time deal going on, where if you use their ZCode desktop app as your harness, you get additional usage limits. Those are time limited and while they might have some additional optimizations for GLM 5.2 in their harness and might have optimized for it somewhat (the same way how you'd expect Opus to work better in Claude Code than OpenCode, though not a given), I'm personally not sure how much value that custom harness would have long term.

Either way, it very much feels like they are doing the right thing, by not locking anyone into their harness but rather incentivizing its use with bonuses, if they want to get more metrics and data through it:

I honestly think that this should be the status quo and the approach that every provider out there takes. You should be able to use whatever tools you want with the tech, given that in the end they get the requests anyways and can infer whatever they need based on those. This also extends to allowing private individuals to use the subscriptions programmatically for other use cases, such as their own custom AI agents and even assistants, like OpenClaw or Hermes.

They technically only want to support a specific subset of software as explained in their usage policy page which in my opinion isn't good enough, but at least it's a step in the right direction and at least currently there's a pretty wide selection of software available.

They and every other provider should know that once the models are both capable enough and have plateaued enough, that there won't be much of a moat and I and many other users will freely move between whatever providers ensure the most pleasant and user friendly experience. The one thing working in our favor here is that the competition is multi-national and we don't get the cartel anti-consumer behavior that RAM manufacturers presently engage in, for example.

Presently I also don't use OpenClaw (or its variants) or agents like Hermes, but their stance to me also seems pretty reasonable, where despite those using a lot of tokens, you are still allowed to, however the routing might be such that you end up with more latency vs those that are doing coding with tools where that might matter a bit more (given that those agents are background heavy).

You can look at it in detail in their docs here:

Contrast that with what Anthropic did for a while, without properly informing users about such a limitation (and long term that would have probably led to a whole bunch of projects including that string as an anti-AI measure):

I also understand that they didn't really have the compute to support OpenClaw being a new thing, but that's one example in a long line of others, of them losing goodwill of the community.

But I digress, back to their custom harness. Initially, I thought that it'd be kind of sloppy and like the early Claude Code Desktop app (nowadays it's way better than it used to be, no more 2 second lag whenever switching sessions), at least based on the main page:

I was, however, wrong. Having used it for a bit, it feels pretty solid.

I don't really know much about who Zhipu AI or Z.ai are, or how big of a dev team they had for this product, or even how long they've been working on it, but it's a pretty usable solution. More thorough than OpenCode's Desktop beta version with most of the features that you'd expect it to have. Now the model itself does not have vision support directly, but they just provide it as one of their MCP servers, it feels like somewhat of a stopgap, but in practice works okay.

Here's what they give you in regards to MCP servers:

• Vision - can look at images for you (doesn't work in Claude Code though)
• Web Search - can do web searches for you, not sure who the provider is but in practice seems okay for western sites
• Web Reader - can fetch webpage content and retrieve it in a way that is okay for the model to use
• Zread - actually not sure why they named it that, but basically it just browses OSS repo docs and code for you

None of those seem perfect, but I will admit that they cover most of your development needs well enough.

In addition, the actual tone that the model has reads a little bit less like overly enthusiastic slop that Anthropic's and OpenAI's models have for whatever reason, which is amusing, given that there have been accusations of large scale distillation by the Chinese AI labs, thankfully they don't seem to have distilled those parts too much:

Those particular claims were against Alibaba, but you'd be silly not to distill the large models as much as you can, when you're outside the jurisdiction of Western courts and can save billions in training costs - it's free real estate! Maybe I shouldn't claim that so brazenly, but to be honest, copyright stopped being something you try to respect that much ages ago.

If you want, here's a look at the full UI, they have pretty useful Git tools and TODO tracking, my only pet peeve would be that you can't easily change the width of the central text column, but otherwise anyone who's used Codex or Claude Code will be immediately at home here:

Something I found a bit odd is that it keeps folders open in the sidebar even when there are no remaining non-archived sessions, but on the other hand I can understand how being able to click the "plus" icon that appears on hover and easily start a new session would be handy. Probably really useful when you're working on like 10 projects, maybe a tad annoying when you have 50:

There's also some slightly puzzling features, such as being able to open a file search/browser from within that same hover menu for the whole folder. I feel like just opening whatever file explorer you have in the directory would probably also have been wholly sufficient and require less dev work, but go figure, it's there if you need it:

They also have an integrated file preview, sometimes when files are mentioned in the main conversation or when you pick something from the file browser they will open up and you'll be able to reference stuff like READMEs and other docs, or even bits of code:

Here's an example of what it looks like when a file is referenced in the conversation and you're also offered a diff. Here I also noticed that not all of the UI is translated, but generally it's usable for someone who only wants to use it in English:

Here's also the integrated diff viewer if you want to use that, though personally I just review the locally committed code in GitKraken (I went back to them from SourceTree because they're the most pleasant way to interact with Git and review diffs that I've found, but curiously I don't really use a lot of their agentic stuff because the UI/UX doesn't seem that great to me, despite that being what they increasingly market themselves on nowadays) before deciding whether I want to push something, manually edit it, or just request further changes:

So, all in all, I'd say that ZCode is pretty nice and I already configured it with DeepSeek V4 Pro as well (seems to work fine) in case the quotas prove to be problematic with just GLM 5.2, although I didn't find a way to let the models switch between the profiles for stuff like sub-agents, sadly that might not be a supported thing yet and probably also really isn't a goal of theirs.

Now, for the thing that will make or break the whole setup: whether the quotas and rate limits are enough to do meaningful work.

The quotas and value aren't great (at least for me)

Their usage policy page talks about what rate limits and quotas you can expect with their plans:

I can confirm that they really aren't lying when they say that with Pro you can expect to do things on one, maybe two projects concurrently. While their caching implementation seems to be okay and the performance itself is passable, if a bit on the slower side, with the Pro plan it is really easy to hit the limits:

I hit the 5 hour quota three times in a single day, using up 60% of my weekly quota, by just doing one long form task across an existing codebase (Django, Vue, some DB work, LLM calls and such) and occasionally asking smaller questions about other stuff in adjacent sessions.

There wasn't anything exceedingly odd about the work itself, it seemed to progress fine, the model wasn't overwhelmed with docs and the most token intensive thing I can think of was using 3 parallel sub-agents for review before each commit in a loop - checking if there are no serious/critical issues, if there are fixing them (unless an obvious false positive evaluation) and continuing that way until everything was resolved, usually resolving within 2 loop iterations, alongside running tests and an in-house linter tool I wrote to check projects against various conventions:

You'll notice that the cache hit rate is over 99%, but I reckon that it's just because this model seems to do the majority of work in the main thread by default, compared to something like using Claude Code with Opus, where it will spawn more sub-agents and also use dynamic workflows. On some level splitting up the one cacheable thread into multiple smaller ones might seem a tad counterintuitive, but at the same time it probably is computationally better and somehow I noticed that it actually makes the quotas be used up a little bit slower for me, not sure why that is.

Even so, normally my cache rate is around 96% so this isn't the most horrible imaginable outlier, at least the cache is working. It might also be that there is a lot of thinking output, because I'm generally running the GLM 5.2 model with Max reasoning on, because that's what most of the benchmarks likening it to Opus used and I want to test the model out at its best, not produce some absolute trash code and then have to spend the same amount of time as the initial implementation just fixing it, and even then having very low confidence in it being okay.

Either way, sadly the Pro plan isn't for me and I'd need to upgrade to their Max one, which would put the prices in line with Anthropic's 5x Max plan, essentially what I'm already paying for. Plus, this is when you consider that they're already giving me bigger quotas, which is nice of them but also doesn't exactly give me that much confidence, especially it's not like I can just sit around and twiddle my thumbs for a good chunk of my working day when they are experiencing peak load times:

It's a shame, because it seems like they're producing a lot of new products (seriously, I had never even heard of them before), including text-to-audio and text-to-image generation, OCR and even their own version of an agentic assistant. I don't expect them to have the same polish as the established players, but they're definitely working on stuff:

Even if some of the marketing reminds me of a digital casino or something, not necessarily a piece of software that I'd want to trust with full computer use. Then again, OpenClaw seemed to skyrocket in popularity despite its architectural security issues, so go figure:

So what else remains? Well, in addition to ZCode and doing some real work in it (that I summarize a bit more below), I also wanted to check how well it works with 3rd party software.

Stretching the Terms of Service a bit

I already checked that it works with OpenCode fine, which I prefer if I have to do work in a terminal, whereas for desktop use I haven't really found anything that good myself - there's Claude Code and Codex but both are quite vendor locked, OpenCode Desktop is passable but still a bit early on, whereas ZCode... well I might actually use it more in the future, I wonder if I'm missing other good options out there, though I've seen that stuff like Conductor also tends to be Mac only, so I'm happy for any cross platform options.

What might be more interesting, I decided to stretch the terms of service a little bit - and see if I can get it running with one of the unsupported options, OpenWebUI. I also had GLM 5.2 make an Ansible task for deploying it on my servers. It had no issues with the task and soon after I had an instance of OpenWebUI up and running:

You can see me connected to DeepSeek V4 Pro there (in addition to GLM 5.2, basically it lets you connect to any OpenAI or Ollama compatible provider) and that's just a quick reminder that the model sometimes does interesting things. When hooked up to the Brave Search API it looked up a bunch of resources, presumably some of which were in Chinese, and in the end also decided to answer in the language to a question in English.

It has no real problem switching back to English when prompted, and it actually summarized the results fine (notice that there were 74 sources) which some of the smaller models can struggle with, but you probably want a model that's as reliable as possible, especially when doing long running tasks and agentic development, which is why I was more seriously looking at GLM 5.2 in the first place:

Either way, it brought up that technically I'm not supposed to use other software, but I can confirm that OpenWebUI also seems to work just fine:

Will it keep working long term? Personally, I wouldn't count on it. Would them suspending me over using something like that, or even including a subscription API key in some other custom software I want to run for my needs locally still be their own loss in the end? Yes.

All things considered, I could imagine a world where known good tools (that also don't waste tokens like crazy) get a 1x quota, their own first party harness gets some 0.Yx multiplier (so a discount), whereas all other unrecognized tools get put in an "other" bucket and are best-effort delivery - which seems to be where things are headed, but simultaneously is still better than what Anthropic did with locking their customers solely into Claude Code:

Either way, there wasn't much other than just setting the correct OpenAI API base URL and providing it with an API key:

• https://api.z.ai/api/anthropic - Anthropic coding subscription
• https://api.z.ai/api/coding/paas/v4 - OpenAI coding subscription
• https://api.z.ai/api/paas/v4 - their generic OpenAI endpoint for pay-per-token

Pretty smooth, overall.

So where does all that leave us? Was the code okay?

So, in the end, their harness was okay and the way they seem to be approaching the whole subscription product also seems pretty nice and I like it more than Anthropic's. Occasionally you can see a lack of polish here and there, but I didn't see any critical issues or problems that would prevent me from daily driving, aside from the quotas.

Even when I mostly worked on one repository and gave it a pretty normal long form task (around 8 new well-scoped small to mid size additions and changes), I still hit the rate limits often, even after all of their discounts. If your usage patterns are anywhere near mine, with their Pro subscription you'd end up looking at output like this a lot:

That's why I wrote a primer script which just pings their API from my servers when I'm sleeping, so that the three intervals I might realistically manage to use within a 24 hour day are spread out nicely:

• 7:00 - 12:00 (if I start work at 9 AM, that's 3 hours of usage)
• 12:01 - 17:00
• 17:01 - 22:01 (mostly personal time)

Or maybe I could move it an additional hour earlier in the morning, to get some more tokens before finishing up my work day. Sadly, none of that would do absolutely anything about the weekly quota, which still is over way too quickly and I'd need to move over to the Max plan.

On the bright side, the work it does is pretty good. I ended up letting Opus evaluate and summarize it, but I can confirm that the code itself is readable, well written and for the most part works fine. None of that DeepSeek unreliability I've seen previously, where it straight up ignored some requirements when doing long-horizon work and where I also had to go back and redo a lot of its output because there were bugs aplenty.

Here's the Claude summary:

At the same time, it missed basic stuff like making sure that the full tooling sweep passes before committing the changes, despite having exact instructions given to do this, as well as putting this in the plan, so that they might not get silently dropped due to some context compaction, and that the tooling must run successfully after any review loop fixes. To some degree, that might be on my prompting and thankfully at least the implementation itself was mostly fine. Opus 4.8 spent another hour doing some additional fixes and improvements and I ended up shipping the feature (sadly it's not a public project, so no demo, albeit I don't mind you seeing some of the session transcripts above) with no issues.

Overall, I burnt around 245 million tokens across all of the work I did when I hit 60% of the weekly allowance. As I write this I've reached 295 million and am at 66% of the weekly quota (it's Tuesday and I'm letting Claude do most of the work today after its own limits reset, goodbye Fable):

Based on that, here are the approximate figures with my usage patterns and caching (including current ZCode quotas and time of day when I work):

• Lite: a bit below 100 million tokens per week
• Pro: 400 - 450 million tokens per week
• Max: around 1.6 - 1.8 billion tokens per week

Without the current ZCode discount, these will dip to around:

• Lite: a bit above 50 million tokens per week
• Pro: 250 - 300 million tokens per week
• Max: around 1.0 - 1.2 billion tokens per week

You might critique the above by saying that it all depends on what the peak time vs off-peak split is and that those aren't all "real" tokens but include cached ones as well, but because we don't get concrete data on exact token numbers either by any of the big providers, this is better than nothing.

In contrast, here's what Anthropic's Max 5x subscription (108 EUR, the cost indicated is the API equivalent) gives me:

If we divide that by 4 weeks in a month, we get about:

• Input: 3.4 million tokens
• Output: 8.1 million tokens
• Cache create: 44 million tokens
• Cache read: 1.3 billion tokens

(these figures might also be a bit higher in practice because usually I get to around 80% - 90% of the weekly limits)

However, those tokens don't necessarily achieve the same results, because the GLM 5.2 release blog post at the top of this article has their first party benchmark illustrating the score difference in agentic development:

I will say that it doesn't mean that GLM 5.2 will always perform worse than Opus 4.8, however you'll need to spend more tokens to get there - instead of me asking Opus to work an hour improving GLM's output, I could instead just make GLM do another pass over its own work and with enough compute budget, it would eventually figure out what's missing (the tools not passing first, the actual code improvements after).

That's also exactly why I make the LLMs use parallel sub-agents for review - since this at least slightly helps with the fact that all our current LLMs are so generation oriented and try to output something relatively quickly, instead of for example exploring an issue and "thinking" about it for an hour and producing code at the end of it that doesn't need to be patched that way. In lieu of completely free thinking effort and CoT budget, this is the best I can do.

However, if we remove the hourly quotas from the Pro plan it would let me blow through the weekly limit in a single day. The Max plan gives me 4x that amount, but a week has 5 work days and I also like to do stuff on the weekends. Either way, it seems like it could at least be approximately workable, it's not like normally it'd go on full send 100% of the time, in this case I at least had clear goals of what I want to do and it just ended up being a bit lengthy.

If they added a way in ZCode to delegate sub-agent tasks to other models, it could be something truly great, since they also have a less capable model called GLM-5-Turbo that I estimate could decrease the amount of tokens I need by 10-20%, similarly to how Claude Code still sometimes lets Haiku do things, even when I'm using Opus primarily.

What should you do and what will I do?

My overall impressions were fairly positive and as long as you don't fear the fact that the model comes from China (though you can probably find an EU or US based provider easily enough, though maybe not the same subscription plan), then I'd genuinely advise that you give it consideration: if you want an open model that's pretty good and do light-medium agentic development, try Z.ai's Pro plan, use it for a month, make your own conclusions. You can do so this month while there's the ongoing discount, if you grab it next week or the week after, I reckon you'll also get at least a week without the discount and will be able to make a decision on whether to continue or not.

It won't be as polished as the other providers, but then again, it didn't have an annoying tone like Opus has and also didn't do refusals like Fable (and historically Opus) does when you touch a bit too much security adjacent code and want a POC for a CVE to see if your system is truly vulnerable to something or not (and additionally get a buy-in from others to actually fix the vulnerability).

We've also largely reached a point where open models are finally good enough to be used as daily drivers (and they get at least 80%, sometimes 90% of the performance of the closed ones). I guess now it all depends on what happens behind the curtain - if Z.ai were subsidizing their subscriptions to a similar degree as Anthropic, we are all still in the middle of an AI bubble and it's not going to be pretty once we get the bill, agentic development just wouldn't be meant to be. On the other hand, if what they're charging is a bit closer to the true costs of the model, which, judging by their API pricing, might at least be a bit closer to that, there might be a chance for us yet.

Their pricing also does seem fair for what you get and it's surprising to see them competing with such bigger orgs:

They also do longer time subscription discounts and those would actually push them into being cheaper than Anthropic Max 5x for me:

I would have to pay 1175 EUR up front, but that'd come out to around 98 EUR per month instead of Anthropic's 108 EUR. I could probably even get the Anthropic's discounted yearly Pro membership for 180 EUR, bringing the total up to 1355 EUR (or a bit more if Anthropic doesn't list VAT, then more like 1394 EUR) for the combination instead of 1296 for just Anthropic Max:

Price wise, it's not a huge difference and with that setup I'd still get occasional usage of Opus to double check the work of GLM 5.2 and also use their other tools like Claude Design and use the mobile/desktop apps for various questions and web searches and research as much as I need, though I would no longer be able to do much development with it directly. Either seems doable, though, and while we're not at a point where we can run GLM 5.2 on some second hand servers in the basement (without quantizing the model to the point of being useless), at least nobody can take the model itself away from us.

Overall, it's nice to see more competitors in the space and I wish them all the best. I might actually pull the trigger and try out their Max subscription. At the same time, Anthropic still gives me more tokens and slightly better performance, that I won't contend with. I don't even dislike them, it's just that they've done some things in the past that at the very least would urge you to look towards alternatives (and also financially support them).

This obviously completely changes if you are paying API rates: if you're stuck on something like AWS Bedrock (and their surprisingly outdated model catalogue) because you need a good SOTA or near-SOTA model provider in the EU, someone running this model for you would basically be a godsend. If I didn't have a subscription, it wouldn't even be something worth considering at length, I'd be using GLM 5.2 through OpenRouter or whatever you prefer daily (though in the case of OpenRouter, I'd check the providers for quantization).

Some predictions, seeing all this

If I were to make any predictions, I'd probably say that if we don't have a huge AI crash, then by 2030 LLMs will hit a point where your confidence in the code they produce (after review + tooling) will be upwards of 95% even if you have a critical view of them, instead of the current mostly-works-but-occasionally-does-stupid-shit, at least in the mainstream development domains. Think along the lines of Fable 5 with max reasoning, but in place of using Sonnet, for every task.

Secondly, if memory manufacturing picks up and chip fabs have good business, somewhere around 2035-2050 it should be possible to run models like that locally at 8 bit quantization or above. I wouldn't claim that about laptops or personal PCs, but motivated people with a chunk of cash and space for a server with 4-8 GPUs or more might be able to get a <1T parameter model running without costs or power usage as exorbitant as with the current enthusiast hardware, without the performance being as trash either; closer to something usable like 50-70 tokens per second.

For example, look at the current Intel Arc Pro B70 which has 32 GB of VRAM and can be had for around 1300 EUR over here. With the current specs I'd need 820 GB for the GLM 5.2 UD-Q8_K_XL quantized version + KV cache, so very roughly around 32 of those cards, give or take. That'd be around 41k EUR at retail (and 3-5x that for fewer but more expensive data center cards on which you'd actually run such a model).

It doesn't feel like science fiction to suggest that if we had relatively affordable enthusiast cards with 256 GB of VRAM and manageable TDP, we could have 4 of those in a server and running something like GLM 5.2 for less than 40k EUR (10k EUR each). Maybe that is even more realistic, seeing how well Qwen3.6 35B A3B performs for its size and that the token efficiency (how meaningful each token is) seems to be going up. I bet we won't even have to wait until 2030 to have small/medium size models (let's say <250B parameters) performing close to current SOTA.

Just kidding, I bet corpos will take every chance to keep the price of memory up and even buying a regular gaming PC will be an expensive endeavor all the way until 2030, at most we'll get better models, but I wouldn't count on affordable hardware for the average consumer.