---
title: I Trusted Z.ai With an Annual Plan, Then Login Broke for 45 Days
description: I bought an annual GLM Coding Plan for ZCode on Linux, then OAuth
  failed with HTTP 500 for six weeks. The timeline, the support loop, the
  snapshot upload incident, and why I recommend the GLM models but not the Z.ai
  platform.
summary: Annual GLM Coding Plan, broken OAuth on Linux, 45 days of support
  loops, a refund, and the silent snapshot upload incident. Why the models keep
  my respect while the platform has not earned my trust.
date: 2026-11-15T00:00:00.000Z
heroImage:
  src: /_astro/hero.BnpPWdpk.webp
  width: 1360
  height: 768
  format: webp
tags:
  - glm
  - z-ai
  - zcode
  - oauth
  - linux
  - developer-experience
  - digital-sovereignty
categories:
  - Technology Bites
  - Middle East Musings
published: true
featured: false
draft: false
author: Jad
href: /posts/glm-coding-plan-support-fiasco/
slug: glm-coding-plan-support-fiasco
---

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][latency-essay], 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](#what-i-bought-and-what-broke-on-day-one)
- [The bug in one curl](#the-bug-in-one-curl)
- [Why the API key fallback was not
  enough](#why-the-api-key-fallback-was-not-enough)
- [The support timeline](#the-support-timeline)
- [The private thread, and the refund](#the-private-thread-and-the-refund)
- [What Roman got right](#what-roman-got-right)
- [The snapshot uploads: why this is bigger than my
  ticket](#the-snapshot-uploads-why-this-is-bigger-than-my-ticket)
- [What this taught me about
  sovereignty](#what-this-taught-me-about-sovereignty)
- [What I would change next time](#what-i-would-change-next-time)
- [Closing: the recommendation](#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][issue-575] on
September 8 with a minimal reproduction that needed no account and no
desktop client:

```bash
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:

```json
{ "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:

```bash
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][issue-575-nov] 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][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.ai` and 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][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][issue-789-r1] and a [second confirmation][issue-789-r2] 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][zai-home] 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][ferstar-post], [HN discussion][hn-thread]). 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][bodega-summary] 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][sina-report], 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][mit-incident] 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][latency-essay]. 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:

1. Start monthly, even when an annual discount tempts. Upgrade only
   after one clean billing cycle and one real support interaction, never
   before.
2. Reproduce server-side bugs early with anonymous `curl`. A 500 that
   needs no login ends every debate about local configs and VPNs.
3. 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.
4. 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.
5. 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][zai-home] 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 `1113` tell 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.

[latency-essay]: /posts/latency-is-political-when-you-live-far-from-the-center/
[issue-575]: https://github.com/zai-org/feedback/issues/575
[issue-575-nov]: https://github.com/zai-org/feedback/issues/575#issuecomment-6642187248
[discord-thread]: https://discord.com/channels/1346756824233148527/1546840396443815936
[issue-789]: https://github.com/zai-org/feedback/issues/789
[issue-789-r1]: https://github.com/zai-org/feedback/issues/789#issuecomment-6244165668
[issue-789-r2]: https://github.com/zai-org/feedback/issues/789#issuecomment-6251435381
[zai-home]: https://z.ai/
[ferstar-post]: https://blog.ferstar.org/en/posts/zcode-silent-workspace-snapshot-upload/
[hn-thread]: https://news.ycombinator.com/item?id=49750694
[bodega-summary]: https://www.bodegaone.ai/blog/zcode-uploaded-git-history
[sina-report]: https://finance.sina.com.cn/tech/roll/2026-09-18/doc-inisfyex3550493.shtml
[mit-incident]: https://airisk.mit.edu/ai-incidents/1714-z-ai-s-zcode-ai-coding-assistant-reportedly-uploaded
