runaiicloud
ModelsAppsGPUsServerless GPUPricingReserveDocsConnectCompareEnterprise
Log inGet started
home/blog/AI coding plans compared (2026): Claude, ChatGPT, GLM, Qwen, Kimi, OpenCode, Subconscious and Token-Max
2026-10-24·Shikhar (runaii founder)·18 min read

AI coding plans compared (2026): Claude, ChatGPT, GLM, Qwen, Kimi, OpenCode, Subconscious and Token-Max

An AI coding plan comparison built on arithmetic instead of vendor list prices: what one agent task costs on the meter, what a 224M-token day costs, and where each flat plan's break-even actually lands — Claude, ChatGPT, GLM, Qwen, Kimi, OpenCode Go, Subconscious and our own Token-Max, every price checked 2026-10-24.

coding-planspricingcomparisoncoding-agentstoken-max
AI coding plans compared (2026): Claude, ChatGPT, GLM, Qwen, Kimi, OpenCode, Subconscious and Token-Max — illustrated summary card

tl;dr

TL;DR — Every flat coding plan hides its ceiling. This comparison prices the same agent workload through eight of them and shows the arithmetic, so the ceiling is a number you can check instead of a quota you have to discover the hard way.

Cheapest entry, published quota: OpenCode Go at $10/month — and unusually, it publishes a monthly dollar limit per model ($60 of GLM-5.3-Flash, $15 of GLM-5.3, $80 of DeepSeek V4.1 Flash), which converts straight into token arithmetic.

Cheapest entry, token-metered: Z.ai's GLM Coding Plan Lite at $18/month, with the only vendor-published token-allowance table in this comparison (146–292M GLM-5.3-Flash tokens per week at a 95% cache-hit rate).

Best published quota model: Subconscious's Team Token Plans — a stated multiple of usage-based value (5x), a stated agentic token mix (98.2% cached input), and a per-model rate card anyone can re-price.

Cheapest blended rate on our own card: Token-Max Solo at $0.0163 per 1M tokens ($49 ÷ the 3B tokens a month its 100M-a-day budget implies). Team prices higher per token ($0.0221) because its card weights flagship tokens 4x. All three are application-gated, which is the honest caveat.

What nobody publishes: Claude, ChatGPT, Qwen and Kimi plan pages give a price and a usage window, not a token number. We print their prices and say so rather than inventing a token allowance for them.

Token-Max coding plans

A billion tokens a day for your coding agents

Flat monthly plans sized for real agent burn — glm-5.3 + qwen3.8 lanes on GPU cells we own and tune. Daily reset, live token meter, OpenAI-compatible. Capacity is limited: apply and see your queue position.

Apply for a plan →Or start pay-as-you-go — $5 free credits

Table of contents

  • AI coding plans compared: what a flat plan actually sells you
  • The plans at a glance
  • What one coding task costs on the meter
  • The heavy day: 224M tokens, priced
  • Metered vs flat: the break-even each plan hides
  • Plan by plan
  • Where runaii.cloud loses
  • Which plan fits your workload
  • FAQ · Glossary · Sources and freshness · Changelog

AI coding plans compared: what a flat plan actually sells you

Disclosure first, because it changes how you should read this. I'm the founder of runaii.cloud, and Token-Max — the flat plan in the last row of every table here — is our product. Our per-token lanes are also in the arithmetic below. The runaii rows are included because leaving them out would make this a worse comparison, not a fairer one; the section where runaii.cloud loses exists for the same reason. Nothing in this post is a benchmark, a latency claim or a measured run: every figure is a published price, a published quota, or arithmetic on those two, and every competitor price carries the date we read it.

Every AI coding plan sells the same thing in a different unit. Claude sells a five-hour session window and a weekly limit. ChatGPT sells "expanded Codex usage" on Plus and "longer sessions" on Pro. Z.ai sells credits on a 5-hour plus weekly dual window and publishes an estimated token table beside it. Alibaba sells monthly credits, Kimi sells agent-allowance multiples, OpenCode Go sells a monthly dollar limit per model, Subconscious sells a multiple of usage-based value, and we sell a daily token budget. The units do not convert, which is why comparison posts usually stop at the sticker price — and why the sticker price is the least useful number on the page.

The way through is to price one workload shape in the one unit everybody can compute — dollars per task — and then ask how many of those tasks each plan's published quota buys. Where a vendor publishes no token number, this post says so instead of guessing. That is the whole method.

The plans at a glance

Entry prices below were read from each vendor's own public page on 2026-10-24, or from codingplan.org's comparison where the vendor's page would not render a price to our fetcher (noted per row). Prices in CNY are left in CNY — we did not fetch an exchange rate, so we do not print a converted dollar figure.

Plan Entry price Quota unit Published token figure Overage
Claude Code (Anthropic) $20/mo Pro ($17/mo annual); Max from $100/mo (5x) or $200/mo (20x) 5-hour rolling session + weekly limits none published usage credits at standard API rates
ChatGPT (OpenAI) Free $0; Go $8/mo; Plus $20/mo; Pro from $100/mo message and usage limits none published not published
GLM Coding Plan (z.ai) $18/mo Lite; $80 Pro; $168 Max (codingplan.org; z.ai says "from $18") credits: 2,000 / 12,000 / 28,000 per 5h; 10,000 / 60,000 / 140,000 weekly yes — estimated tokens per week at 95/96/98% cache hit none: quota, then wait for reset
Qwen Token Plan (Alibaba Cloud) ¥39/mo Lite; ¥139 Standard; ¥499 Pro monthly credits: 11,500 / 45,000 / 180,000 none published Pro: overage at 12% off
Kimi Code (Moonshot) ¥49 Go (no coding quota); ¥99 Plus; ¥199 Pro; ¥699 Max 5-hour rolling window, no weekly cap for new members none published extra-usage top-up
OpenCode Go $10/mo Go; $40/mo Go Plus monthly dollar limit per model yes — $60 GLM-5.3-Flash, $15 GLM-5.3, $80 DeepSeek V4.1 Flash, $30 Qwen3.8 Flash hard stop at the limit
Subconscious usage-based from the Marathon rate card; Team Token Plans $1,000 / $5,000 / $10,000 per month multiple of usage-based value (5x) no token figure — a stated agentic mix (98.2% cached input) and a 5x usage-value multiple past the day's usage, usage-based pricing
Token-Max (runaii.cloud — ours) $49/mo Solo; $199/mo Team; $499/mo Max daily token budget yes — 100M / 300M / 1B tokens per day (≈3B / 9B / 30B per month) application-gated; no published overage

Two things stand out before any arithmetic. First, only three of the eight publish a token number you can divide a price by — Z.ai (an estimate), OpenCode Go (a dollar limit), and us (a daily budget). Second, four of the eight publish no token number at all, so for Claude, ChatGPT, Qwen and Kimi the buyer is comparing a price against a quota with no common denominator. That is not a comparison; it is a vibe.

What one coding task costs on the meter

Define the task, then price it. One coding task here is a single agent session that processes 50,000 fresh input tokens, re-reads 200,000 cached prompt tokens (the prefix an agent re-sends every turn), and writes 8,000 output tokens — 258,000 tokens in total. That shape is our own modelling choice, stated so you can substitute your logs; it is not a measurement of any vendor.

The calculation, at the rates on our catalog on 2026-10-24 (per 1M tokens):

glm-5.3          ($1.40 fresh / $0.26 cached / $4.40 output)
  fresh   0.050M x $1.40 = $0.0700
  cached  0.200M x $0.26 = $0.0520
  output  0.008M x $4.40 = $0.0352
  task total             = $0.1572

deepseek-v4-flash ($0.22 / $0.022 / $0.66)
  fresh   0.050M x $0.22 = $0.0110
  cached  0.200M x $0.022 = $0.0044
  output  0.008M x $0.66 = $0.0053
  task total              = $0.0207

qwen3.8-flash    ($0.40 / $0.04 / $1.60)
  fresh   0.050M x $0.40 = $0.0200
  cached  0.200M x $0.04 = $0.0080
  output  0.008M x $1.60 = $0.0128
  task total              = $0.0408
Lane (our catalog rates) Per task Tasks per $1 Tasks per $49 plan Tasks per $199 plan Tasks per $499 plan
deepseek-v4-flash ($0.22 / $0.022 / $0.66) $0.0207 48.4 2,367 9,614 24,106
qwen3.8-flash ($0.40 / $0.04 / $1.60) $0.0408 24.5 1,201 4,877 12,230
glm-5.3 ($1.40 / $0.26 / $4.40) $0.1572 6.4 312 1,266 3,174

The last three columns are plan price divided by per-task cost — the same arithmetic as the block above, applied to the three Token-Max prices. It is the only honest way to put a metered lane and a flat plan on one axis: dollars per task, then tasks per plan.

Note what is not in that table: our catalog's fourth row, GLM-5.3-Flash at $0.15 / $0.03 / $0.50, because the same catalog file flags that id as retired from serving. It stays in the file for old URLs and legacy keys; it is not a lane we will sell you today. Check the live catalog rather than any table, including this one.

The heavy day: 224M tokens, priced

Our own published measurement of a real coding-agent workload is 1.6B tokens all-time, a peak day of 224M tokens, and 93% of prompt volume served from cache — that receipt is on llms.txt, and it is the same shape our earlier coding-agent cost comparison models. At 93% cache reads, a 224M-token prompt day is 208.32M cached and 15.68M fresh, plus 8M output (the output assumption from that same model).

Lane (catalog rates) Cached 208.32M Fresh 15.68M Output 8M Heavy day 30 such days
glm-5.3 ($1.40 / $0.26 / $4.40) $54.16 $21.95 $35.20 $111.32 $3,339
deepseek-v4-flash ($0.22 / $0.022 / $0.66) $4.58 $3.45 $5.28 $13.31 $399
qwen3.8-flash ($0.40 / $0.04 / $1.60) $8.33 $6.27 $12.80 $27.40 $822

Each row is cached tokens × cached rate + fresh tokens × fresh rate + output tokens × output rate, at the catalog's published rates on 2026-10-24. Component cells are rounded to the cent; the totals are computed from the unrounded products, which is why a column can add to a cent more or less than the total. The spread between our cheapest and most expensive lane on an identical workload is 8.4x ($13.31 to $111.32) — the output column and the flagship's cached rate do that, not the headline input price.

One heavy day at that shape is roughly 868 tasks (224M ÷ 258K). That is the number to hold in your head when reading a plan's quota: a 100M-token daily budget is about 388 tasks, and a 1B-token daily budget is about 3,876.

Metered vs flat: the break-even each plan hides

This is the part the comparison sites skip, ours included until now. A flat plan is worth its price when the metered bill for your workload exceeds it. So price the month, then compare.

Our Token-Max tiers, at the page's own daily token figures:

Tier Price Daily budget Monthly tokens Blended $/1M
Solo $49 100M tokens/day ≈3B $0.0163
Team $199 300M tokens/day ≈9B $0.0221
Max $499 1B tokens/day ≈30B $0.0166

Blended price is price ÷ monthly tokens: $49 ÷ 3,000M = $0.0163 per 1M; $199 ÷ 9,000M = $0.0221; $499 ÷ 30,000M = $0.0166. Team prices higher per token than Solo because its card lists "glm-5.3 flagship at 4× token weight" — flagship tokens consume the budget four times faster. That is on the page; it is also a reason to read the card rather than the price.

Now the break-even against the meter. A 224M-token day exceeds Solo's 100M daily budget, so the comparison is against Team (300M/day):

  • Team at $199 vs deepseek-v4-flash at $13.31/day: 199 ÷ 13.31 = 15.0 heavy days a month. Below 15 heavy days, metered is cheaper; above, the plan is.
  • Team at $199 vs qwen3.8-flash at $27.40/day: 199 ÷ 27.40 = 7.3 heavy days a month.
  • Team at $199 vs glm-5.3 at $111.32/day: 199 ÷ 111.32 = 1.8 heavy days a month.

Z.ai's published allowance, converted: their estimated token table gives GLM-5.3-Flash at 146–292M tokens per week on Lite at a 95% cache hit, 877–1,755M on Pro, 2,047–4,095M on Max. A 224M-token day is 1.568B tokens a week, so Lite covers 0.65–1.3 heavy days per week, Pro 3.9–7.8, Max 9.1–18.3. Their table, their arithmetic — we only divided.

OpenCode Go's published limits, converted: the $10 Go plan caps GLM-5.3-Flash at $60 of list-rate usage a month, with a 5-hour window at 20% of the monthly limit ($12) and a weekly window at 50% ($30). One heavy day at the same 208.32M / 15.68M / 8M shape on that lane's published $0.15 / $0.03 / $0.50 rates prices at $12.60, so a single heavy day slightly exceeds the whole 5-hour window and the $60 monthly limit is 4.8 heavy days. Their GLM-5.3 limit is $15 a month — 0.13 of one heavy day at $111.32.

Subconscious's published mix, converted: their pricing page states an agentic mix of 98.2% cached input, 1.6% uncached input and 0.2% output. At their GLM-5.3 Marathon rates ($1.40 / $0.26 / $4.40), 1M tokens at that mix costs 0.982 × $0.26 + 0.016 × $1.40 + 0.002 × $4.40 = $0.2865. Their $1,000 Base plan is stated as 5x usage value ($5,000+ a month), which at that mix is ≈17.5B tokens a month.

Claude, ChatGPT, Qwen and Kimi: we can price none of them per task from public pages, because none publishes a token figure for a plan. Claude's plans give a 5-hour rolling session window plus weekly limits, with usage credits at standard API rates once you hit them; ChatGPT's cards describe "expanded" or "longer" Codex usage without a number; Qwen's plan is sold in monthly credits (11,500 / 45,000 / 180,000) and Kimi's in agent-allowance multiples, and neither page we fetched converts credits to tokens. Anyone who prints a token allowance for those four is estimating, and we would rather leave the cell empty than fill it with our guess.

Plan by plan

1. Claude Code — the reference experience, priced by the session

Verdict: the plan most people are actually comparing against, and the one whose ceiling is deliberately unquantified.

Price (checked 2026-10-24): Free $0; Pro $20/month, or $17/month on annual billing ($200 up front); Max from $100/month, with a 5x or 20x usage multiplier over Pro; Enterprise $20 per seat per month plus usage at API rates. Claude Code is included on all paid plans and draws from the same pool as chat.

Why pick it: the strongest model quality on the list, one bill across terminal and chat, and a documented escape hatch — turn on usage credits and keep working at standard API rates when you hit the ceiling.

Decision notes: Fable 5.1 bills via usage credits on Pro and is capped at 50% of weekly limits on Max. Usage limits reset on a rolling five-hour window with weekly limits on top, and Anthropic publishes no token number — so the honest comparison is price and model access, not tokens per dollar.

2. ChatGPT — Codex usage, sold as a message allowance

Verdict: the other default, with the same opacity: a price, a usage window, and no token figure.

Price (checked 2026-10-24): Free $0; Go $8/month; Plus $20/month; Pro from $100/month with three usage tiers. Codex access is "limited" on Free, "expanded" on Plus, and "longer sessions" on Pro; Pro adds GPT-6 Astra reasoning.

Why pick it: if your team already lives in Codex, this is the plan that keeps it there, and the $8 Go tier is the lowest USD entry price in this table.

Decision notes: OpenAI's plan cards render their prices client-side, so we read the rendered page rather than the HTML source; and "expanded usage" is not a number. Budget on the ceiling you observe in your own account, not on the card.

3. GLM Coding Plan (z.ai) — the only vendor that publishes an estimated token table

Verdict: the only plan here that publishes an estimated token allowance for its tiers, which makes it the one credit-based plan you can sanity-check before subscribing.

Price (checked 2026-10-24): Lite $18, Pro $80, Max $168 per month (codingplan.org); Z.ai's own docs say "starting at just 18 USD per month" and their subscribe page reads "Plans from 18/month". Credits are 2,000 / 12,000 / 28,000 per 5 hours and 10,000 / 60,000 / 140,000 per week. Model usage = (input × multiplier + cached input × multiplier + output × multiplier) ÷ 10,000, with GLM-5.3 at 6.9 / 1.7 / 24 and GLM-5.3-Flash at 2.3 / 0.56 / 8. Off-peak usage bills at 50%; peak is Monday–Friday 14:00–18:00 Singapore time.

Why pick it: it is the only plan in this list that tells you roughly how many tokens a week buys, and its own numbers are checkable: at a 95% cache-hit rate, Lite gives 146–292M GLM-5.3-Flash tokens a week, Pro 877–1,755M, Max 2,047–4,095M. Those are Z.ai's estimates, not measurements.

Decision notes: credits are not tokens, and MCP calls also consume them (1.2 credits per call at the output multiplier), so a heavy MCP user lands below the token table. The plan is also restricted to officially supported tools; API calls outside the plan are not available, per their FAQ.

4. Qwen Token Plan (Alibaba Cloud) — credits in CNY

Verdict: the widest model list among the credit-based plans, priced in monthly credits we cannot convert.

Price (checked 2026-10-24, via codingplan.org): Lite ¥39/month for 11,500 credits, Standard ¥139 for 45,000, Pro ¥499 for 180,000, with overage at 12% off on Pro and a limited-time 60% night discount. The plan lists Qwen3.8-Max (0902), Qwen3.8-Flash, Kimi-K3, DeepSeek-v4-pro, Qwen3-VL-Plus and Qwen-Image-3.0-Pro.

Why pick it: if you want one subscription covering several model families including a flagship, this is one of the widest model lists in the comparison.

Decision notes: credits are not tokens on any public page we could fetch, and the price is in CNY — we print ¥39 and do not convert it, because we did not fetch a rate. Treat the credit-to-token ratio as a question for the vendor.

5. Kimi Code (Moonshot) — the plan whose entry tier does not include coding

Verdict: a 5-hour rolling window with no weekly cap for new members, and a trap in the tier ladder.

Price (checked 2026-10-24, via codingplan.org): Go ¥49 (no coding quota), Plus ¥99, Pro ¥199, Max ¥699 per month; annual billing is lower on every tier.

Why pick it: K3 at Plus, and 1M-token conversation context plus K2.7 Code HighSpeed at Pro and above, with no weekly cap for new members.

Decision notes: the ¥49 Go tier is not a coding plan — Kimi Code needs Plus or above, and that is stated on their own plan card. Agent-allowance multiples (2x, 4x, 14x) are not tokens; there is no published token figure.

6. OpenCode Go — the only plan that prices its own ceiling

Verdict: the best-documented quota in the comparison, because it is a dollar limit per model rather than a percentage of "usage."

Price (checked 2026-10-24): Go $10/month, Go Plus $40/month. Each model carries a monthly dollar limit — $60 for GLM-5.3-Flash, $15 for GLM-5.3, $80 for DeepSeek V4.1 Flash, $30 for Qwen3.8 Flash — with 5-hour usage at 20% of the monthly limit, weekly at 50%, and monthly at 100%. Token prices inside the plan are the same as the model's list rate ($0.15 / $0.03 / $0.50 for GLM-5.3-Flash; $1.40 / $0.26 / $4.40 for GLM-5.3).

Why pick it: the ceiling is a number. OpenCode Go and Z.ai are the only two plans here whose published quota converts to tasks-per-month without a guess, and OpenCode's is the more precise of the two because it is denominated in dollars. At the plan's own flash rates, the task shape above prices at $0.0175 (0.05 × $0.15 + 0.20 × $0.03 + 0.008 × $0.50), so the $60 monthly GLM-5.3-Flash limit is 4.8 heavy days or ≈3,430 tasks.

Decision notes: the limits are per model, not pooled, and the 5-hour window is 20% of the monthly figure — one heavy day at $12.60 does not fit inside a $12 window. The flagship lane's $15 monthly limit is roughly 0.13 of a heavy day, so this is a flash-class plan wearing a long model list.

7. Subconscious — the plan that publishes its own token mix

Verdict: the most re-priceable subscription here: a stated multiple of usage-based value, plus the agentic mix they assume.

Price (checked 2026-10-24): usage-based GLM-5.3 Marathon at $1.40 / $0.26 / $4.40 and DeepSeek V4.1 Flash Marathon at $0.30 / $0.007 / $1.40 per 1M; Team Token Plans at Base $1,000/month (5x, 100 concurrent), Team $5,000/month (500 concurrent), Heavy $10,000/month (1,000 concurrent); usage resets daily at midnight UTC and past the day's usage moves to usage-based pricing.

Why pick it: the multiple is explicit (5x), the assumed mix is explicit (98.2% cached input / 1.6% uncached / 0.2% output), and the rate card is the same as the model's list price — three claims you can check against each other.

Decision notes: at $1,000 a month the entry Team plan is priced for teams putting agents into production, not for one developer; and 5x value is their arithmetic on their mix, not a token guarantee.

8. Token-Max (runaii.cloud) — our plan, and its ceiling is a daily token budget

Verdict: flat monthly plans on GPU cells we run, with a quota you can count — application-gated because capacity is physical.

Price (checked 2026-10-24, from our plan page): Solo $49/month for 100M tokens a day (≈3B/month, 15 concurrent requests); Team $199/month for 300M a day (≈9B/month, 50 concurrent, GLM-5.3 at 4x token weight, priority queue); Max $499/month for 1B a day (≈30B/month, 100 concurrent, capacity-booked cell time). Daily budget resets nightly, the meter is live in the console, and the API is OpenAI-compatible.

Why pick it: the quota is the product — a token number, not a message count — and the daily reset means one runaway agent day does not eat the month.

Decision notes (the honesty part): you cannot buy it with a card. Seats are application-gated and reviewed, so there is a queue, and metered per-token access is the self-serve path in the meantime. And the per-token blend is not the cheapest on this page — OpenCode Go's $10 buys $60 of GLM-5.3-Flash list-rate usage, which is a better deal than any of our tiers at that model and that volume. We say so in the next section.

Where runaii.cloud loses

Three places, stated plainly.

  1. Flash-class volume on a $10 plan. OpenCode Go's $10 tier includes $60/month of GLM-5.3-Flash at list rates — 4.8 heavy days' worth — for about a fifth of our Solo price. If all you run is flash-class traffic at low volume, they are cheaper and it is not close.
  2. Frontier intelligence. Claude and ChatGPT plans include frontier closed models; we serve open models only. If a task needs Opus 5.5 or GPT-6-class reasoning, that is a routing decision, and a flat plan that hides it is not a substitute for one.
  3. Self-serve signup. Our plans are application-gated; Claude, ChatGPT, GLM, Kimi, OpenCode and Subconscious all let you pay and start. If you need a seat in five minutes, we are the wrong row.

One more thing we will not do: claim our per-token rates are cheaper than they are. GLM-5.3 on our catalog is $1.40 / $0.26 / $4.40, and Subconscious's GLM-5.3 Marathon row and OpenCode's GLM 5.3 row are the same three numbers. On that model, the per-token table does not differentiate us at all — the plan structure does.

Which plan fits your workload

  • You want the cheapest published ceiling: OpenCode Go at $10, because the dollar limit per model converts to tokens without a support ticket.
  • You want the best model quality and will pay for it: Claude Pro at $20, or Max at $100–200 if the five-hour windows keep closing on you.
  • You are already in Codex: ChatGPT Plus at $20 is the reference; the $8 Go tier is the cheapest entry if your usage is light.
  • You want a token-metered plan with a published estimate: Z.ai's GLM Coding Plan — Lite at $18 if you work mostly off-peak, Pro if you run more than about four heavy days a week.
  • You want one subscription across model families: Qwen's Token Plan lists the widest model set in this comparison, priced in CNY credits.
  • You run agents all day and want a number, not a vibe: Token-Max Team at $199 for 300M tokens/day breaks even at about 15 heavy days a month on our cheapest metered lane — and the daily reset means one bad day does not consume the month. Apply through the plan page and read the queue position before you plan around it.
  • You are not ready for a plan at all: metered inference on our catalog is the honest default — one task at the shape above costs $0.0207 on deepseek-v4-flash.

Sources and freshness

Every price below was read on 2026-10-24, in the session that wrote this post.

  • runaii.cloud catalog and src/lib/catalog.ts — our per-token rates: glm-5.3 $1.40 / $0.26 / $4.40 (202,752 context), deepseek-v4-flash $0.22 / $0.022 / $0.66 (1,048,576), qwen3.8-flash $0.40 / $0.04 / $1.60 (32,768). The catalog's fourth row, GLM-5.3-Flash at $0.15 / $0.03 / $0.50, is flagged retired from serving in the same file, so it is excluded from the tables.
  • runaii.cloud/token-max — the three plan prices ($49 / $199 / $499), the daily budgets (100M / 300M / 1B tokens), the monthly equivalents (≈3B / 9B / 30B), concurrency (15 / 50 / 100), the 4x GLM-5.3 token weight on Team, and the application gate.
  • runaii.cloud/llms.txt — the published workload receipt used for the heavy-day model: 1.6B tokens all-time, a 224M-token peak day, 93% of prompt volume served from cache.
  • claude.com/pricing — Claude Free $0, Pro $20/month ($17/month annual, $200 up front), Max from $100/month with 5x or 20x usage, Enterprise $20 per seat plus usage, the five-hour rolling session window with weekly limits, Fable 5.1 usage-credit treatment, and Claude Code's inclusion on paid plans.
  • chatgpt.com/pricing — ChatGPT Free $0, Go $8, Plus $20, Pro from $100, and the Codex usage wording. The plan cards render their prices client-side, so we read a text rendering of that page rather than its HTML source.
  • docs.z.ai/devpack/overview — GLM Coding Plan credit tables (2,000/10,000 Lite; 12,000/60,000 Pro; 28,000/140,000 Max), the credit formula, the GLM-5.3 and GLM-5.3-Flash multipliers (6.9/1.7/24 and 2.3/0.56/8), the MCP multipliers, the 50% off-peak rate, peak hours (Mon–Fri 14:00–18:00 Singapore time), and the estimated token allowance table at 95/96/98% cache-hit rates.
  • docs.z.ai/devpack/faq — plan-only quota behaviour (no balance deduction once the quota is exhausted) and the supported-tools restriction.
  • codingplan.org/en — GLM Coding Plan tier prices ($18 / $80 / $168, annual $12.6 / $56 / $117.6), the Qwen Token Plan tiers (¥39 / ¥139 / ¥499 for 11,500 / 45,000 / 180,000 credits, overage at 12% off, night 60% off), and the Kimi Code tiers (¥49 / ¥99 / ¥199 / ¥699, no weekly cap for new members). Used because those vendors' own plan pages did not render prices to our fetcher.
  • opencode.ai/docs/go — OpenCode Go $10/month and Go Plus $40/month, the per-model monthly dollar limits, the 20%/50%/100% window structure, and the in-plan token prices.
  • subconscious.dev/pricing — the Marathon rate card, the Team Token Plans ($1,000 / $5,000 / $10,000 with 5x usage value and 100/500/1,000 concurrent requests), the daily UTC reset, and the stated agentic mix of 98.2% cached input / 1.6% uncached / 0.2% output.

Not verifiable from public pages this session, and therefore not printed as numbers: a token allowance for any Claude, ChatGPT, Qwen or Kimi plan; a credit-to-token conversion for Qwen's or Z.ai's credits; a USD conversion for the CNY prices; and any per-task cost for a plan that publishes no token figure. Where a row lacks a number, that is the reason.

Prices and quotas in this market change monthly at best. Every table here carries its pull date; treat anything older than a week as a question rather than a quote, and re-check the live catalog before you budget against our rows.

Changelog

  • 2026-10-24: initial publication. All competitor prices read on 2026-10-24 from the vendor pages listed above, or from codingplan.org's comparison where the vendor page would not render a price to our fetcher (Z.ai tier ladder, Qwen and Kimi tiers), stated per row. Our rates come from src/lib/catalog.ts as of the same date; GLM-5.3-Flash is excluded from the tables because the catalog flags it retired from serving. Worked arithmetic: one task at 50K fresh / 200K cached / 8K output costs $0.0207 (deepseek-v4-flash), $0.0408 (qwen3.8-flash) and $0.1572 (glm-5.3); a 224M-token day at a 93% cache-hit rate costs $13.31 / $27.40 / $111.32; Token-Max Team's break-even is 15.0 heavy days a month against the cheapest of those lanes. Re-verify every price and quota monthly, and immediately if any listed vendor reprices.

FAQ

▸What is the cheapest AI coding plan in 2026?

On the prices we verified on 2026-10-24, the lowest entry prices are ChatGPT Go at $8/month, OpenCode Go at $10/month and Z.ai's GLM Coding Plan Lite at $18/month. Cheapest entry and best value are different questions: OpenCode Go publishes a $60 monthly dollar limit for GLM-5.3-Flash, which converts to about 4.8 heavy days at our modelled 224M-token day, while Z.ai publishes a weekly token estimate that puts Lite at 0.65–1.3 heavy days a week.

▸How much does one coding-agent task cost?

At the shape used in this post — 50,000 fresh input tokens, 200,000 cached prompt tokens and 8,000 output tokens — one task costs $0.0207 on deepseek-v4-flash, $0.0408 on qwen3.8-flash and $0.1572 on glm-5.3 at our catalog rates on 2026-10-24. That is 48.4, 24.5 and 6.4 tasks per dollar respectively. Your own fresh/cached/output ratio is the number that matters; substitute it.

▸Is a flat coding plan cheaper than paying per token?

It depends on how many heavy days you run. At our modelled 224M-token day, the cheapest metered lane in our catalog bills $13.31 a day, or $399 for 30 such days — about twice the $199 Token-Max Team plan, which breaks even at 15.0 heavy days a month. Below that, metered is cheaper. Plans with no published token figure cannot be checked this way at all, which is the point.

▸Why do Claude and ChatGPT plans not publish a token allowance?

They publish usage windows instead: Claude resets on a rolling five-hour session with weekly limits on top, and ChatGPT's cards describe "expanded" or "longer" Codex usage without a number. Both sell model access and an experience, not tokens, and both route overage differently — Claude through usage credits at standard API rates, ChatGPT with no published overage rate. Treat any token-per-dollar figure you see for them as an estimate by whoever printed it.

▸What is the difference between credits and tokens?

Credits are a plan's internal accounting unit. Z.ai deducts (input × multiplier + cached input × multiplier + output × multiplier) ÷ 10,000 credits per request, Alibaba sells 11,500–180,000 monthly credits, and neither publishes a credit-to-token rate for every model. Tokens are the unit the meter actually bills; a plan that publishes a token figure can be compared, and a plan that publishes only credits cannot.

▸Does a flat plan include cached input?

Every plan here draws from one pool, so cached reads consume the same quota as fresh tokens unless the vendor says otherwise. Z.ai is the exception that documents it: cached input has its own multiplier (1.7 for GLM-5.3, 0.56 for GLM-5.3-Flash), which is why their token estimate varies with cache-hit rate — 146–292M a week on Lite at 95%, rising to 158–317M at 98%.

▸Which plan should a solo developer on a budget pick?

If your usage is light and flash-class models are enough, OpenCode Go at $10 with its $60 GLM-5.3-Flash monthly limit, or ChatGPT Go at $8 for chat and light Codex. If you run agents most days and want one model family, Z.ai's Lite at $18 is the cheapest token-metered plan with a published estimate. If your daily volume is above 100M tokens, none of the cheap tiers fit and you are choosing between a metered bill and a plan sized for it.

▸How was this comparison verified?

Every competitor price was read from that vendor's own public page on 2026-10-24, and each row names the page. Where a vendor's page would not render a price to our fetcher we used codingplan.org's comparison and said so in the row. Our own rates come from our catalog on the same date. No number here is an estimate by us except where the arithmetic is labelled as modelled, and no token allowance is attributed to a vendor that does not publish one.

Glossary

Coding plan
a subscription that grants model access inside coding tools for a flat monthly price, metered by a quota (credits, tokens, dollars or a session window) instead of a per-request invoice.
Quota window
the period a plan's allowance resets on: a rolling five-hour session (Claude, Kimi, GLM), a day (Token-Max, Subconscious), a week (GLM's second window), or a month (OpenCode Go, Qwen).
Credits
a plan's internal accounting unit, deducted per request by published multipliers or per-token conversion; not a token, and not convertible to one without the vendor's table.
Cached input
prompt tokens whose prefix the provider already processed, billed at a discounted rate; agents re-send their prefix every turn, so most of an agent's prompt volume is cached input.
Cache-hit rate
cached tokens divided by total prompt tokens over a window. Our published workload reads 93%; Subconscious assumes 98.2% for agentic coding; the rate changes a plan's effective token allowance more than its price does.
Token budget
a daily or monthly token allowance expressed in tokens rather than credits, dollars or message counts; the only quota unit that converts directly to a metered bill.
Heavy day
in this post, a 224M-token prompt day with 8M output tokens, modelled on our published peak-day measurement of a real coding-agent workload.
Break-even day count
a flat plan's monthly price divided by the metered cost of one heavy day; the number of heavy days a month at which the plan becomes cheaper than paying per token.
Application-gated
a plan you must apply for and be approved into, because the capacity behind it is physical and finite, rather than a plan you can buy instantly with a card.

Token-Max coding plans

A billion tokens a day for your coding agents

Flat monthly plans sized for real agent burn — glm-5.3 + qwen3.8 lanes on GPU cells we own and tune. Daily reset, live token meter, OpenAI-compatible. Capacity is limited: apply and see your queue position.

Apply for a plan →Or start pay-as-you-go — $5 free credits
Keep reading
What a coding agent really burns: 1.6B tokens of receipts2026-10-24Claude Code alternatives (2026): priced, sourced, honest2026-10-24How to run Qwen3.8 27B in 2026: the two-minute API path, the honest local guide, and the break-even math2026-10-14

On this page

Table of contentsAI coding plans compared: what a flat plan actually sells youThe plans at a glanceWhat one coding task costs on the meterThe heavy day: 224M tokens, pricedMetered vs flat: the break-even each plan hidesPlan by plan1. Claude Code — the reference experience, priced by the session2. ChatGPT — Codex usage, sold as a message allowance3. GLM Coding Plan (z.ai) — the only vendor that publishes an estimated token table4. Qwen Token Plan (Alibaba Cloud) — credits in CNY5. Kimi Code (Moonshot) — the plan whose entry tier does not include coding6. OpenCode Go — the only plan that prices its own ceiling7. Subconscious — the plan that publishes its own token mix8. Token-Max (runaii.cloud) — our plan, and its ceiling is a daily token budgetWhere runaii.cloud losesWhich plan fits your workloadSources and freshnessChangelog
runaiicloud

Serverless inference, dedicated GPUs, and training for open models. OpenAI- and Anthropic-compatible APIs.

© 2026 runaii

Platform

Model libraryAppsGPUsServerless GPUPricingToken-Max coding plansCompare providersDocs

Developers

ConnectCookbookCLIAgents / MCPUse casesTutorialsBlogFAQ

Company

EnterpriseStartupsAboutCareersTrust centerStatusSupportTermsPrivacyData policySubprocessorsSitemap