---
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][glm-hf] Coding Plan because
the offer was generous and the timing felt right.

On paper, it had everything I wanted: [ZCode][zcode-home] on Linux, a 150
percent quota multiplier, and 8 million daily event tokens. I had
already leaned heavily on [GLM][glm-hf] models through a
[Devin][devin-home] 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][glm-hf]
models are genuinely good, and [Zhipu][zhipu-home] as a research lab
keeps my respect. [Z.ai][zai-home] 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][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][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][discord-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][issue-575], the [789 thread][issue-789] eventually got a
community-discovered root cause. On October 16, [Z.ai][zai-home]
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][discord-thread] 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][discord-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][zai-home]'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][zai-home]. 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][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][zai-home] 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][zcode-repo] 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][glm-hf] 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][glm-hf] 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][glm-hf] 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][zai-home]'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][glm-hf] the models: yes.** Nothing in this stretch
dented my respect for Zhipu's engineering, and I will happily run
[GLM][glm-hf] 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/
[glm-hf]: https://huggingface.co/zai-org
[zcode-home]: https://zcode.z.ai/
[zcode-repo]: https://github.com/zai-org/zcode
[zhipu-home]: https://www.zhipuai.cn/
[devin-home]: https://devin.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
