In early September, I bought an annual GLM Coding Plan because the offer was generous and the timing felt right.
On paper, it had everything I wanted: ZCode on Linux, a 150 percent quota multiplier, and 8 million daily event tokens. I had already leaned heavily on GLM models through a Devin subscription, where they proved fast and dependable. Writing from the Middle East about digital sovereignty, I also wanted a capable provider outside the usual American labs in my daily stack. I wanted this to work.
It did not. What followed was 45 days of broken logins, quiet inboxes, and a support loop that ended in a partial refund.
There is a clear split at the heart of this experience. GLM models are genuinely good, and Zhipu as a research lab keeps my respect. Z.ai as a platform, meaning the ZCode client, the auth stack, and the support queue wrapped around those models, has not earned the same trust. Here is the full record of those six weeks, why I now recommend the models but not the platform, and what would have to change for that verdict to flip.
What’s in this post:
- What I bought, and what broke on day one
- The bug in one curl
- Why the API key fallback was not enough
- The support timeline
- The private thread, and the refund
- What Roman got right
- The snapshot uploads: why this is bigger than my ticket
- What this taught me about sovereignty
- What I would change next time
- Closing: the recommendation
What I bought, and what broke on day one
The bargain was simple. Pay upfront for a year, sign in to ZCode Desktop with the Coding Plan, and let subscriber routing unlock the bonus quota. For heavy agent work on Linux, it looked like one of the stronger deals on the market.
On my machine, sign-in never finished. The browser step ended with a
cheerful “Sign-In Complete” banner, the zcode://oauth/callback deep
link fired back to the desktop app, and then ZCode failed to exchange
the authorization code for a token. Every attempt died at that exact
handoff.
I tried the community workaround shared by a volunteer moderator, a small login-fix script built for Coding Plan auth. Nothing changed on my Linux setup, which pointed away from my desktop and straight at the token endpoint itself.
That suspicion became the thread I pulled for the next six weeks.
The bug in one curl
After a few days of retries, I filed issue 575 on September 8 with a minimal reproduction that needed no account and no desktop client:
curl -sS -X POST -H "Content-Type: application/json" \
-d '{"provider":"zai","code":"AAAAAAAAAAAAAAAAA","codeLength":17,
"redirect_uri":"https://zcode.z.ai/app/oauth/login?redirect=zcode%3A%2F%2Foauth%2Fcallback&app_version=3.11.2",
"state":"00000000000000000000000000000000"}' \
https://zcode.z.ai/api/v1/oauth/token
The response, every time:
{ "code": 2007, "msg": "http error" }
HTTP 500, even for a dummy code that should fail fast with a clean 4xx. For comparison, an empty payload validated normally:
curl -sS -X POST -H "Content-Type: application/json" \
-d '{}' https://zcode.z.ai/api/v1/oauth/token
That returned HTTP 400 with code 3001, parameter error. The route was
live, schema validation worked, and the moment a request included both
state and redirect_uri, the exchange handler threw an unhandled
exception upstream.
That single test mattered because it took my network, my proxy, my Linux environment, and my account off the suspect list. Anyone, on any machine, could trigger the 500 without ever logging in.
Update, November 2026: the bug outlived my subscription. A
fresh confirmation posted on November 4 shows the OAuth
flow still failing identically on ZCode 3.17.2, this time on Windows,
with desktop logs confirming the deep link fires while the exchanged
token never arrives. Anonymous probing in that report shows the failure
signature has shifted from HTTP 500 with code 2007 to a bare HTTP 429
with an empty body for the exact state plus redirect_uri payload the
client must send, suggesting an edge or rate-limiter rule now intercepts
it before the handler. Control payloads still pass. Other commenters note
that the broken flow locks them out of 5-hour quotas and promo tokens
tied to the logged-in session, and at least one pair of users let their
plans expire without a refund.
Why the API key fallback was not enough
Early on, a moderator suggested the pragmatic bypass: skip OAuth, paste a personal API key into ZCode, and keep coding while the dev team investigated. I took that advice. It got requests moving, but it quietly moved me into a different billing bucket.
As the moderator later explained, OAuth binds the desktop session to the Coding Plan tier, which unlocks the 150 percent multiplier and the daily event tokens. A pasted API key routes through the standard personal key limiter, with its rolling 5-hour caps and none of the subscriber bonus.
So I was paying as an annual Coding Plan subscriber and burning quota like a plain API user. Every time I hit a 5-hour wall, the math was concrete: the same session, authenticated through the plan, would have carried 50 percent more headroom. The fallback was not a workaround. It was a quiet downgrade I had never agreed to.
The support timeline
Here is the compressed timeline, drawn from my public Discord thread, two GitHub issues, and my inbox. Discord links require server membership and threads can vanish, so the beats below preserve the record:
- Days 1 to 3 (early September): OAuth fails on Linux from the first launch. I try the community fix, confirm the HTTP 500, and file issue 575 on September 8. A volunteer moderator, Roman, responds quickly and stays helpful throughout. He confirms this is a known rare bug on the dev team’s list.
- Days 3 to 5: I email
user_feedback@z.aiand wait two days with no reply. In the public Discord thread, staff member Agnes asks me to resend with the subject “Human review required” and zero URLs or screenshots attached. I ask how to report a server-side reproduction without URLs. She tells me to try. I send a stripped plain-text email and hope it clears the filter. - Day 10: Five days after the second email, still nothing in my inbox. I post in the thread noting that I cannot access the campaign benefits I paid an annual fee for. I am told to wait for a limit reset. The reset buys a few hours of breathing room, while the login endpoint remains dead.
- Weeks 3 to 4 (September 22 onward): The fallback breaks too.
Inference starts failing across ZCode, leaving the UI stuck in an
infinite “reconnecting” loop. On September 22, I file issue
789 for error
1113(“Insufficient balance”) on an active paid plan. At this point, two core flows are broken at once: I cannot sign in with the plan, and I cannot reliably use the API key bypass.
Unlike 575, the 789 thread eventually got a community-discovered root
cause. On October 16, Z.ai published documentation separating Standard
and Coding Plan API keys, explaining that a Standard key bills the cash
balance on every endpoint and triggers 1113 even on a valid
subscription. Two days later, users ran a four-key
experiment and a second confirmation on
fresh and renewed plans, proving that keys created in September also
failed unless issued specifically from the Personal Coding Plan tab
and paired with the coding endpoint. The error message itself,
"Insufficient balance, please recharge," never once hinted at key type.
Users had to reverse-engineer their own billing rules while support
stayed silent.
Meanwhile, Roman escalated my ticket again and asked Agnes to bring in an engineer. I shared my account identifier privately and confirmed that web login still worked. On the desktop client, nothing moved.
The private thread, and the refund
By week five, Agnes moved the conversation into direct messages. She asked about my network, my proxy, and whether I had restarted the client, then confirmed that my subscription showed as active on her dashboard.
I understand why frontline support runs through a checklist. Still,
after five weeks of documented curl output, two GitHub issues, and a
public thread packed with logs, being asked to reboot and check my Wi-Fi
felt dismissive. I told her so plainly. I had already verified the
network path with Roman. The 500 reproduced for anonymous callers with
no account. There was nothing left on my laptop to restart.
She asked for my model settings next and pointed me to the coding
endpoint, https://api.z.ai/api/coding/paas/v4, with the plan model
selected instead of the API option. I sent the screenshot. The loop
kept turning: another menu to check, another screenshot to upload,
another stretch of waiting.
Around day 40, tired and blunt, I asked her to confirm Z.ai’s registered company details in Beijing and Singapore so I could file a formal complaint. She declined to provide them and offered a prorated refund instead.
The offer came back at 122 dollars for the unused remainder of the year. I accepted it, and wrote in the thread at the time that I was taking it as the only exit offered, not as a fair resolution. I had burned over a month of an annual plan on a broken auth endpoint, plus hours of my own debugging and bug reporting.
Agnes said she submitted the refund and asked me to watch my bank statement. I asked for a Stripe tracking code and a confirmation email from Z.ai. At the time of writing, I am still watching for both.
What Roman got right
This story has one quiet hero. Roman, a volunteer moderator, did what the official support channel failed to do for six weeks. He replied fast, named the failure honestly, explained the quota difference between OAuth and a pasted API key, and escalated twice without forcing me to re-litigate the file from scratch.
Volunteers should not have to carry paid customer support. When they do, they deserve credit. Without his telemetry notes, I would have spent far longer proving why a pasted key was lossy and why waiting for a limit reset could never cure an HTTP 500 on token exchange.
If Z.ai wants to keep builders who commit to annual plans, that standard of competence has to live inside the paid support queue, not only in Discord threads staffed for free.
The snapshot uploads: why this is bigger than my ticket
My ticket would be a minor support anecdote if it stood alone. It did not. On September 18, ten days after I filed issue 575 and weeks before my refund thread closed, ZCode itself became the center of a privacy incident that hit Hacker News, Chinese tech press, and the MIT AI Risk database.
A paying subscriber writing as ferstar published a teardown titled
“Inside ZCode: Silently Uploading Your Entire Git History to the Cloud”
(original post, HN discussion). After
noticing ~/.zcode eating 700 MB on a small MacBook Air, he traced what
ZCode 3.12.3 was doing in the background. While logged in, a hook fired
before every prompt, packaged the entire workspace into a tarball with
full .git history included (roughly 87 percent of the payload),
encrypted it with a key only the server could open, fetched upload
credentials from zcode.z.ai, and POSTed the archive to Alibaba Cloud
storage. Turning off both privacy toggles stopped neither the packaging
nor the upload attempts, and the privacy policy made no mention of
snapshots. An independent verification confirmed the
blast radius: ferstar’s 313 MB commercial repository hit a size ceiling
564 times and never left his network, while a smaller public repository
did upload, and another user reproduced the upload on Windows.
To its credit, Z.ai responded the same day. In a statement reported by Sina, the company attributed the pipeline to a default-enabled codebase indexing feature, said uploaded archives were destroyed immediately after Wiki generation and never retained, and promised to open-source ZCode for third-party review alongside a quota reset. Version 3.14.0 removed the upload pipeline, the credential endpoint now returns 404, and the client source landed on GitHub under Apache 2.0. The event is now logged as MIT AI Risk incident 1714 under privacy and security.
Skeptics still have real unanswered questions. The open-source drop arrived as two flattened commits with no traceable git history of the upload removal, pull requests locked, and issues disabled. The released code implements checkpoints as purely local Git diffs, undercutting the claim that checkpoint restore required remote uploads. And as ferstar pointed out, an audit showing an empty storage bucket after the fact cannot verify what happened to snapshots uploaded beforehand, or say who held the decryption keys for those archives. For balance on the other side, a separate early claim alleging six uploaded workspaces was later retracted, so I keep the proven findings and the open questions in separate piles.
I include this incident because it reframes my support ticket. A 500 on an OAuth endpoint is a bug. Silent whole-repo packaging encrypted with a server-held key is an architectural posture. Both point to the same habit: the client and platform layer around GLM models has treated user machines and user trust with less care than a paid developer tool owes its buyers. The detail ferstar noted stings the most: he was a GLM Coding Max subscriber who had recommended ZCode to friends the very night before he caught it.
What this taught me about sovereignty
I write often about digital sovereignty, and this purchase stress-tested my own thesis. I chose GLM partly because I want serious alternatives outside the American cloud stack. That goal has not changed. Model quality was never the issue here, and Zhipu remains a lab I respect.
Sovereignty, though, is not only about where weights are trained. It is also about whether a paying developer in another region can get a straight answer, a timely fix, or a clean refund when authentication breaks. Trust is infrastructure. A 500 on a token endpoint is a normal software failure. Forty-five days of silence, circular triage, and lost subscriber quota are what break the relationship.
For builders in the Middle East and everywhere else far from every vendor headquarters, support responsiveness is latency of another kind. It decides whether we can stomach annual lock-in, recommend a tool to a client team, or bet production habits on a new platform.
What I would change next time
A few practical rules I am keeping for myself, and for anyone buying agent tooling across borders:
- Start monthly, even when an annual discount tempts. Upgrade only after one clean billing cycle and one real support interaction, never before.
- Reproduce server-side bugs early with anonymous
curl. A 500 that needs no login ends every debate about local configs and VPNs. - File one public issue per failure mode, with exact client versions, request bodies, and expected versus actual status codes, and link related issues when they compound.
- Audit the cost of every workaround. “Just paste an API key” can quietly forfeit the quota tier you paid for. Check which rate limiter each auth path hits, and which tab issued the key.
- Set a refund deadline before you need one. Mine is now fixed: if a paid core flow stays broken for two billing weeks with no named owner and no lossless workaround, I open the refund request alongside the bug report.
None of those habits would have fixed Z.ai’s token endpoint. All of them would have cut weeks off my personal loop.
Closing: the recommendation
I did not want a refund. I wanted the plan I paid for: ZCode on Linux, signed in over OAuth, running on the quota I bought. I isolated the bug, answered every triage question sent my way, and waited through silence I would not ask any reader to put up with.
So here is the recommendation that those 45 days earn, split down the middle. GLM the models: yes. Nothing in this stretch dented my respect for Zhipu’s engineering, and I will happily run GLM weights through an API client or router I trust.
Z.ai the platform: not yet. Skip ZCode, skip the Coding Plan checkout, and especially skip annual lock-in until four things change:
- The OAuth flow works across platforms and stays working after updates.
- Support answers in days with named owners instead of weeks of reset scripts and repeated triage.
- The snapshot upload incident is closed with a full third-party audit and a plain answer on who held past decryption keys.
- Billing and gateway errors like
1113tell users what is actually wrong instead of blaming their account balance.
If you ran ZCode prior to 3.14.0, run the hygiene checklist the independent writeups recommend: upgrade past the fixed release, rotate any secret that ever sat in the Git history of a repo you opened in the app, and treat every privacy toggle in every cloud coding tool as a training opt-out until a packet capture proves otherwise.
I am publishing this because blunt feedback is part of buying software
early. When paying users stay quiet about broken auth and slow queues,
vendors lose the signal required to fix them. When we put dates, status
codes, and curl payloads on the record instead of venting, we hand them
a checklist they can actually ship against.
The models earned my interest. The platform around them still has to earn my trust, and now it has a clear list of what it takes.
Recommended
Continue reading
Selected from shared topics, related tags, and the recent archive.