Read the new price list like a state diff. Before: 49 RMB, 149 RMB, 469 RMB. After: 118 RMB, 538 RMB, 1078 RMB. The deltas: +141%, +261%, +130%. One tier moved more than twice as hard as its siblings. Price changes should be roughly monotonic if cost pressure were uniform. This one isn't. That non-linearity is the first bug in an announcement that is about to become a specification document for the entire Chinese AI coding industry.

The second bug is structural. Zhipu AI's GLM Coding Plan is abandoning prompt-count limits for a credit system. Input tokens, output tokens, cached tokens, and MCP calls are now metered separately and flattened into a single points ledger. A middleware layer between your usage and your wallet. No exchange rate published.

And the provenance matters. This report arrived through Beating, an AI-focused outlet, and was forwarded through blockchain and Web3 channels before landing here. That is not coincidence. It is appropriate. Because what Zhipu just executed has a precise name in my world: a fee market change without a published gas table.

The old plan was capped by prompts per five hours and per week. The new plan is capped by credits. Priced in. Metered across four resource dimensions. Everything consumed, everything billed, nothing auditable from outside the settlement layer.

Why This Is a Protocol Story

Let me establish ground truth, because the raw numbers matter more than the narrative spin. Zhipu AI is one of China's most prominent large-model vendors, with the GLM family of open and commercial models at its core. The GLM Coding Plan is its subscription product for AI-assisted programming: a chat-plus-completion environment with multi-turn repository context, running on Zhipu's own inference infrastructure.

The previous V2 structure had three tiers: Lite at 49 RMB per month, Pro at 149 RMB per month, Max at 469 RMB per month. Demand overwhelmed supply to the point of rationing, roughly four hundred new slots per day at 10 AM, a clock-based admission control mechanism that turned subscribing into a daily lottery. The source material describes this as a limited release. I describe it as a priority queue with a time-based nonce. It was not a scarcity illusion. Real users queued, real demand outstripped real GPU capacity.

The new structure keeps three tiers: Lite at 118 RMB per month, Pro at 538 RMB per month, Max at 1078 RMB per month. Increases of 141%, 261%, and 130%. Existing V2 subscribers retain legacy pricing for renewals and upgrades. V1 users get a window, with the purchase entry expected around mid-August, to buy at the old V2 price before the wall comes down. New users face the full table.

The stated rationale is a purity exercise: from counting prompts, a crude proxy, to counting actual resource consumption. The credit system recognizes four resource classes: input tokens, output tokens, cache tokens, and MCP calls.

Stop on that detail. No one meters cache tokens unless cache hits are a meaningful fraction of marginal cost. No one meters MCP calls unless they are serious about becoming an agent platform. And no one implements granular metering without first instrumenting their entire inference stack. This announcement is a financial product. Its underlying infrastructure is an accounting engine. The model is the collateral.

The surface reading: a Chinese AI vendor raising prices, breaking the domestic-equals-cheap heuristic. The industry reading: AI coding tools are shifting from subsidized acquisition to monetization. The deeper reading, the protocol reading, is that Zhipu just implemented the closest thing the AI industry has produced to a gas market. And they did it in a way that exposes exactly where the bottleneck in the AI infrastructure stack actually lives, the same way a fee market exposes contention in a blockchain.

A caveat on information quality: the source is a secondhand industry brief, not a Zhipu engineering document. Prices and percentages are credible. The causal stories built around them are inference. I will flag confidence levels as I go, the way I would flag certainty on an unaudited codebase.

The Missing Gas Table

In blockchain protocols, resource metering requires a public conversion function. Ethereum has the yellow paper. EIP-1559 defines base fee formulas. Every opcode has a cost. The point is not that the fees are fair; it is that they are knowable in advance. You can simulate a transaction and compute its full cost before broadcast. That is the minimum condition for rational market participation.

Zhipu's credit system lacks that condition. The announcement lists four metered dimensions but publishes no conversion rates. How many credits does a typical code-completion task consume? What is the input-to-output token ratio? Is a cache hit ten times cheaper than a cache miss, or 1.1 times? Is an MCP call billed per request, per tool, or per round-trip? No answers. The meter exists; the metering standard sits in a proprietary box under the counter.

That is a design orientation with consequences I recognize from a decade of reading whitepapers as executable specifications. In 2019, as an undergraduate in Nairobi, I spent three months dissecting Uniswap v1's constant-product invariant, manually tracing the variable swaps until I found an integer overflow in eth_to_token_swap_input that every automated scanner had missed. The bug was not in the math. It was in an undocumented assumption about integer widths. Opaque accounting surfaces are where those assumptions hide.

Code is law, but bugs are reality. The first bug in this pricing contract is that users cannot verify whether their credits were consumed correctly. No usage-log API. No worked example of a typical task's credit cost. No per-request deduction instrument. The source report itself lists credit consumption speed as an open question. That is not an oversight. It is an interface decision. In the absence of a visible gas table, every user's balance is backed by faith in a closed ledger, a single source of truth with no block explorer.

Translate that into market terms. A developer paying 538 RMB per month deserves to know how many output tokens that represents. Without that number, a rational comparison against Cursor Pro at twenty dollars per month or GitHub Copilot at ten dollars per month is impossible. The comparison every smart buyer wants to make is blocked. That is not an accident, it is a feature. Opaque pricing is a lock-in mechanism wearing a billing system's clothes.

The Cache Token Tell

The most informative line in the entire announcement is the existence of a separate billing category for cache tokens. Read it like a protocol state variable. It tells you more about the product architecture than any benchmark ever could.

Caching in LLM inference means storing the key-value state of a context window so that repeated requests skip re-computation of attention. For a coding assistant this is enormous: files, repositories, and conversation histories get re-scanned across every turn and every edit. Without caching, inference cost scales with total context processed. With caching, the marginal cost of re-reading a known context drops by orders of magnitude.

By metering cache tokens as their own class, Zhipu is implicitly pricing two tiers of context: cold writes and warm reads. The likely design, which the source does not confirm, makes cached tokens cheaper than fresh input. That is a subsidy for session persistence and long-lived contexts. Rational, even elegant: cache hits reduce GPU load, cut latency, and improve perceived responsiveness. But it is also a steering mechanism. The pricing schedule is encoding a preferred usage pattern into the fee market, the same way an L1's fee schedule encodes preferences for calldata versus computation.

I saw this dynamic before the AI boom. In 2021, after six weeks analyzing the composability surface between Lido's stETH and Aave, I published a deep dive arguing that liquid staking derivatives were creating a shadow banking system inside Ethereum. The structural pattern repeats here: a derivative layer, the credit system, mediating access to an underlying scarce resource. The stETH version had a centralization vector in Lido's node operators, who could effectively censor transfers. The GLM version has a comparable vector: the cache. Whoever controls the cache controls the cost of repeat interactions. If Zhipu decides to evict a user's context, the effective price of every subsequent operation doubles or worse. That is a censorship surface, enforced not by social policy but by accountancy.

And there is the custody problem. Caching your repository means your code, including proprietary, unreleased, or security-sensitive logic, persists in a server-side cache. The source report flags the same concern without resolving it: code may be stored on Zhipu's infrastructure with an unclear deletion mechanism. In DeFi, when a protocol holds user funds without disclosed custody terms, we call it custody risk. The exact analogue here is code-custody risk. The credit system does not create that risk, but it monetizes it. The vendor has a financial incentive to keep your code cached and no disclosed mechanism for you to verify deletion. Privacy has become a metered resource with a missing audit trail. That is a new class of obligation, and the terms of service have not caught up with it.

In 2024, when I led the analysis of Celestia's data availability sampling, we spent weeks verifying that nodes only need a small subset of blobs to guarantee availability. The latency bottleneck we found was in the gRPC layer, not the mathematics. The same principle applies here: the sampling mechanism, the credit meter, is only as trustworthy as the interface that reports it. And this interface reports nothing.

MCP Billing Is an Agent Tax

The third metered resource is the one the casual reader will skip. MCP calls.

MCP, the Model Context Protocol, is the standard plumbing for connecting an LLM to external tools. An MCP call is not a generation. It is an execution. The model invokes a tool, reads a file, hits an API, mutates a remote service, or orchestrates a fleet of subprocesses. By metering it, Zhipu declares that GLM Coding Plan is no longer a chatbot with code completion. It is an agent runtime with a metered tool-call pipeline.

This is the frontier where my two obsessions, AI systems and consensus protocols, collide. In 2026, I spent three months auditing an oracle network that claimed to feed AI-generated predictions on-chain. My finding was boring and fatal: non-deterministic model outputs violated consensus requirements, making validation impossible without a trusted intermediary. AI and crypto do not converge because someone prints a token. They converge when the verifiability problem is solved. MCP calls are a verifiability minefield. When an agent executes a tool call, who verifies the side effects? Who audits the permission boundary between the model's intent and the tool's authority? A misconfigured MCP permission is a reentrancy vulnerability in slow motion. The function signature looks innocent. The state changes it triggers are not.

The pricing structure treats MCP calls as a billable dimension, which means Zhipu is positioning itself as the settlement layer for tool execution, not just language generation. That is the seed of a function marketplace: storage, execution, API round-trips, all metered and denominated in a non-transferable credit token. It is, architecturally, an application-specific rollup for developer labor, except the ledger is closed and the ordering of operations is decided by a single sequencer: Zhipu's backend team.

Zero-knowledge isn't magic; it's mathematics wearing a mask. What we have here is the inverse: unverifiable accounting wearing the mask of precision. The system asks users to trust, in a single bundle, the credit meter, the exchange rates, the cache retention policy, and the MCP permission model. Any one of those is a rational thing to demand an audit trail for. All four together, with no disclosure, is a blind signing request.

The security analysis here carries a C-grade confidence. The source contains no security documentation, but the billing architecture alone exposes the attack surface. A cache with ambiguous eviction policy and an MCP gateway with unclear authorization scopes are the two most probable entry points for data leakage and supply-chain compromise. I would not connect a mission-critical repository to this system until both are specified in writing.

The Dual-Track Pricing Contract

Now the commercial layer, read the way I would read an unaudited smart contract: look for the time locks.

The migration structure: V2 users locked at legacy prices on renewal and upgrade; V1 users granted a mid-August window to buy at the old V2 price; new users paying the full table. That is a two-phase migration contract with asymmetric rights. Existing holders retain their basis. New entrants pay the mark. And a deadline is set to manufacture urgency.

This pattern exists in crypto for a reason. When a protocol wants to change fee parameters without triggering a user revolt, it grandfathers existing positions and front-loads conversion incentives. Zhipu is doing precisely that. The V1 window is a conversion event. The mid-August date is a settlement deadline. The message to every price-sensitive developer is binary: commit at the old rate now, or accept the new rate forever. That is emotional engineering with a calendar.

The 261% hike on the Pro tier is the most aggressive signal in the table. Pro is the middle lane, the professional developer segment, the heavy user, the high-volume generation consumer. A 261% increase is not a cost pass-through. Cost structures do not triple in a quarter. It is a demand test. Zhipu is using price as a filter exactly the way a congested L1 uses gas price: allocating scarce capacity to the highest-value transactions. The 10 AM quota was a naive admission control mechanism. The new price schedule is a priority auction with a reserve price.

But filtering only works if the capacity constraint is temporary. If GLM's next model generation cuts cost per token, the credit exchange rates can be recalibrated downward, and the effective price becomes competitive again. If not, this is a quiet market exit for the price-sensitive majority. The investment thesis embedded in this announcement, on which my confidence is D because no financial data exists in the source, is that the strategy is aimed at a future funding round or IPO, where monthly recurring revenue at higher ARPU looks better than user count at negative margin. Price hikes before a raise are standard practice in every market. The question is whether the revenue survives contact with the churn curve.

The Competitive Matrix

Let me build the trade-off matrix, because a price without a position is just a number.

Against the international baseline: GitHub Copilot at roughly ten dollars per month, about seventy RMB, and Cursor Pro at roughly twenty dollars per month, about 140 RMB. Zhipu's Pro tier at 538 RMB is about 3.8 times the price of Cursor and roughly 7.7 times the price of Copilot. Even the Lite tier at 118 RMB undercuts nobody; it sits above Copilot's mass-market price. The source's price comparisons are consistent with my own reference data through mid-2025, so the arithmetic holds.

What would justify 3.8 times the price of Cursor? Three candidates: model quality on Chinese-language and Chinese-repository code, an integrated ecosystem bundling model plus cache plus MCP services, and enterprise-grade compliance for data residency. Zhipu has a real bundle for Chinese enterprises: domestic model sovereignty, no cross-border data transfer, private deployment options. That is a defensible premium for a specific buyer. It is not a defensible premium for the average global developer.

The switching-cost analysis matters more than the price. Most developers do not have strong lock-in to a coding assistant. The model is replaceable; the habits are not. Plugin ecosystems, keyboard muscle memory, and repository conventions create mild friction, but nothing like the cost of migrating a smart contract deployment or re-platforming a data layer. In protocol terms, the exit game is cheap. That means the market is one strong discount campaign away from user flight. Tongyi Lingma, CodeGeeX, Cursor, Copilot, and the next wave of open-source agent frameworks are all watching the same dashboard. Zhipu's price hike is their acquisition budget.

The pricing strategy also carries an implied bet on model uniqueness. If GLM's code generation capability is dramatically better on Chinese codebases, the premium survives. If it is merely comparable, the market will arbitrage the difference within two quarters. The source provides no benchmarks, no HumanEval scores, no SWE-bench rankings. That absence is itself data. A vendor with a dominant benchmark would publish it.

Contrarian: Supply Capitulation, Not Pricing Power

The consensus narrative will frame this as pricing power. Demand is strong; the vendor raises prices; value capture proceeds. In that story, Zhipu is a rational monopolist testing the demand curve.

I read it as the opposite: a capitulation.

Look at the sequence again. Rationed distribution at 10 AM. Then a switch to credit-based metering. Then a 130 to 261 percent price increase with no disclosed quota expansion. That is not the behavior of a vendor with abundant compute and improving margins. It is the behavior of a vendor whose unit economics are deteriorating. The credit system is not a billing feature. It is a cost-recovery instrument. Every token class became expensive enough to meter individually, and the meter was switched on precisely when the old model was losing money on heavy users. The previous prompt-count cap was a crude, gameable metric: users could stuff massive contexts into a single window and generate long outputs while paying a flat fee. Zhipu was eating the variance. The credit system transfers that variance to the user. It is a risk-misalignment correction, dressed as product intelligence.

The deeper blind spot is the precedent. Zhipu is a flagship. When the flagship raises Pro pricing by 261 percent, it normalizes the behavior across the entire domestic industry. The era of subsidized Chinese AI coding tools is over. That will not be announced in a press release. It will be discovered in competitor price tables over the next two quarters. And in that process, the developers with the lowest switching costs will vote with their terminals. The winners will not be the vendors with the best models. They will be the ones who can subsidize compute longest, exactly like the L1 wars of the last cycle, where the real contest was never technology but treasury size.

There is also an information-asymmetry risk that the market will misprice. By raising prices without disclosing entitlement changes, Zhipu creates a narrative vacuum. Users will assume the worst: that they are paying 261 percent more for the same service. Whether that assumption is true or false will determine the reputational aftermath. In my experience auditing protocols, the worst outcomes come not from bad parameters but from unannounced changes to those parameters. Code is law, but the comments matter too.

Takeaway

The question is not whether 538 RMB is too much for a coding tool. It is whether the meter is honest.

Watch for one document in the coming quarters: a published conversion table. Credits per token. Credits per cache hit. Credits per MCP call. Credits per representative task. If that table appears, this is the maturation of a real fee market, and competition will shift to transparent unit economics. If it does not, then this price hike is what it looks like from inside a protocol: a privileged validator extracting rent from an uninformed user set, with no block explorer and no state root.

The state diff at the top of this article was a metaphor. A verifiable diff is a fact. A price list without a gas table is just a headline. Developers know better. They run nodes. They verify. The question is whether they will apply the same standard to their own subscriptions, or keep spending on faith. Satoshi's peer-to-peer electronic cash died on the ETF approval; what survives is settlement infrastructure for institutional flow. Developer trust is the only currency that still requires proof of reserves. Zhipu just asked the market to spend it on a closed ledger.