Grok Build is metering you. GLM-5.3-Flash on 4× RTX PRO 6000 is not.

1. Why 30% already feels like a lot

Grok subscriptions since June 2026 share one compute-weighted weekly pool across Chat, Imagine, Voice, and Build. xAI does not publish a token number. The Usage page shows a percentage. Agent and Build tasks draw more than chat by design — Grok said so on X when Heavy users burned 25–30% in a day of backend work.

That matches the lived experience: two projects, a couple of looping tasks, 30% gone. You are not “light.” Looping agents re-send growing context every turn. The meter is weighting that, not counting prompts.

The only public, instrumented SuperGrok week I trust is Ben Bishop’s $30 plan hitting 100% after 31 Grok Build sessions (Mission Control extract, week of 10–17 Aug 2026):

Price that mix at Grok 4.6 API rates ($2 / $0.50 cached / $6 per 1M, prompts <200K):

9.658M × $2  +  305.717M × $0.50  +  1.231M × $6  =  $179.56

So 100% of a $30 SuperGrok week of real Build work is about $180 of Grok 4.6 API. Thirty percent of that week is about $54 of API. Bishop is explicit that this is not “the official quota in tokens” — it is the workload recorded while the meter hit 100%. It is still the best ruler we have.

2. The two models

AA cost per Intelligence Index task

Artificial Analysis, captured 28 Aug 2026. Flash ~10.4× cheaper per Index task. VentureBeat’s same-day chart used ~$0.09 vs ~$0.94 and called it “about 10× for a four-point gain.”

3. How big is the downgrade?

Short version: small on coding/agent benches, real on token thrift and product glue, not a cliff.

AA model pages, 28 Aug 2026. Coding sub-scores on AA are charts, not a single published Flash-vs-4.6 Terminal-Bench cell I could copy without the interactive UI. Same-harness Rails/OpenCode numbers below are for GLM-5.3 (flagship), not Flash — treat as an upper bound on the family.

What the same-harness coding runs actually said

• Agents on Rails (17 Aug): Grok 4.6 completed 52/63 runs; GLM-5.3 (flagship, not Flash) 50/63. GLM-5.3 re-ran the test suite ~20 times per run vs 3–6 for most models — it spends tokens to get there.
• AkitaOnRails OpenCode suite: GLM-5.3 scored 94 in 80 min (~$2.59 API); Grok 4.6 scored 92 in 34 min ($6.33 API). Flash is the cheap sibling of that family, not the 94-point model.
• Z.ai’s Flash pitch is “rivals Opus 4.8 on coding/agentic” at one-tenth of GLM-5.3 list. Unsloth repeats that. Independent AA puts Flash at 57 vs Grok 4.6 at 61 — believe AA for the gap, believe Z.ai for “this is a serious coder, not a toy.”

Where you will feel it in an agent loop

This is the same emerging stack as the Grok 4.5 vs Opus 5 brief, with the executor slot swapped: plan/review on Grok 4.6 (or Opus), execute volume on Flash. If you drop Grok entirely, expect more human review, not a collapsed product.

4. Quant on 4× RTX PRO 6000

Assumption, stated so it can be wrong: 4× RTX PRO 6000 Blackwell, 96 GB each, 384 GB total, SM120. That is the card every current GLM-5.3-Flash serving recipe targets. If these are Ada 48 GB cards (192 GB total), skip to the callout — NVFP4 does not have a comfortable home there.

Sizes: Unsloth GLM-5.3-Flash docs (28 Aug 2026); 0xSero NVFP4 182 GiB lock; tpurtell EXL3 “roughly 165 GiB.” Accuracy column is Unsloth’s top-1% retention vs BF16, not a coding-agent eval.

Run NVFP4. It is the quantization that keeps both speed and user experience on this silicon. Unsloth’s 4-bit dynamic GGUF is the quality floor you should refuse to go under (93%). NVFP4 is 4-bit weights consumed as W4A4 on Blackwell Tensor Cores, with FlashInfer CUTLASS MoE that actually has an SM120 module. CuteDSL MoE is compiled for datacenter Blackwell (sm100/103) and dies on SM120. That is why the 4× recipe pins flashinfer_cutlass.

Do not run Q3/Q2 on a 384 GB box to “go faster.” 0xBakeer’s Qwen 3.8 work (different model, same lesson) showed the 4-bit advantage vanishing under concurrency: +27% at c=1, +0.2% at c=16. Once a batch is sharing a weight read, extra quant is mostly quality you threw away.

5. How many concurrent agents

Two measured recipes, not a vibe:

What those numbers mean for agents, not benches

User-experience number: 8 concurrent agents on one NVFP4 replica. That is the batch size the 4× recipe actually captured graphs for. Above 8 you trade latency for aggregate tokens. For looping coding agents overnight, 16 is the honest throughput cap I would set before measuring.

Max-concurrency play if the goal is “peg the box”: two EXL3 replicas, TP2 each (the 165 GiB quant fits on 2×96 GB). Then you have 8+8 interactive or 16+16 scheduler slots, and a dead replica does not take down the farm. 0xSero’s single TP4 replica is simpler and faster per stream (208 vs 107 tok/s C1). Pick TP4 if you want one fat endpoint; pick 2× TP2 if you want agent count.

6. OpenRouter vs Grok vs a $300 subscription

Same Bishop mix (9.66M in / 306M cache / 1.23M out). This is one week of Grok Build that filled a $30 SuperGrok meter. Reprice it three ways.

Promo matches OpenRouter’s z-ai/glm-5.3-flash as of 26–28 Aug 2026. Budget against list. Cache is the column that matters in agent loops; Flash list cache is $0.03 vs Grok 4.6’s $0.50 (17×).

What a $300 SuperGrok Heavy month is worth

xAI will not say. Two honest brackets:

• Price-ratio 10× SuperGrok: if a maxed $30 week is $180 of API, a maxed Heavy week is $1,800, a maxed Heavy month (4.3 weeks) is ~$7,700 of Grok 4.6 API. That is under $10k.
• Burn-rate 6× (Plus sits at $100; Heavy users still dump 30% in a day of Build): ~$4,600/month of API if you somehow hit 100% every week.

You will not hit 100% every week on Heavy without turning Grok Build into a job. Bishop had to work at it on the $30 plan. Heavy’s 16-agent mode also burns the pool faster per wall-clock hour. Treat $5k–$8k of Grok 4.6 API per fully used Heavy month as the range, not $10k.

Task counts, using Bishop’s 31 sessions / $30 week as “a SuperGrok-week of looping agent work”:

So: OpenRouter Flash does the same Bishop-shaped week for about $11 list instead of $180 of Grok API or a slice of a $30–$300 subscription. The catch is quality and verbosity, not the invoice.

7. The sheet — 100 tasks, $300, $10k, $61k

One ruler, three invoices. The mix is Bishop’s SuperGrok week (9.66M in / 306M cache / 1.23M out) priced at Grok 4.6 API, then repriced at OpenRouter GLM-5.3-Flash. “Same tasks” inflates Flash output 2.1× and loops 1.3× from the AA verbosity gap, so you are comparing finished work, not token count.

A “Bishop-session” is one of those 31 Grok Build sessions (~40k output tokens with that week’s cache ratio). The original “100 tasks = a weekly Grok limit” hypothetical is in the table even though the measured SuperGrok week was 31, not 100.

What $300 of Flash credits buy, vs emptying Heavy

Bishop mix at list: 9.658M × $0.15 + 305.717M × $0.03 + 1.231M × $0.50 = $11.24, vs Grok $179.56 (16.0×). Promo is half. “Same tasks” is $15.10 for that week (11.9×). $10k and $61k rows reprice the Grok token mix, not equal merged PRs. Local power for the pegged farm is $237–$394/month (§8) — that is the $61k row’s real bill, not $3,843.

Before you cancel Heavy

• Keep Heavy if ~$5k–$8k of Grok-quality work per month is enough, you want Grok Build as a product, and the weekly meter is annoying rather than blocking. The subscription is cheaper per Grok-dollar than Flash list when you actually fill it.
• Move loops to OpenRouter Flash if the box is not up yet, or you want overflow with no weekly cap. Budget $626/month for $10k of Grok-eq at list, ~$3,840/month to match a pegged 4× farm. Put $300 of credits on Flash and you have roughly a Heavy month of volume without the meter.
• Move loops to the 4× box if you are going to live in the $10k–$61k Grok-eq band. Electricity is a few hundred dollars. OpenRouter at that scale is still thousands. Keep one Grok (or Opus) seat for plan/review.

8. Can the 4× box print $10,000 of Grok-equivalent?

Yes. $10k is not the ceiling. It is a light-duty month.

Pegged-farm math (one NVFP4 replica)

Conservative decode aggregate at C8 on 4×: 400 tok/s (the 2× EXL3 box already did 336 aggregate at C16 adaptive; 0xSero’s 4× C1 is 208). Agent loops are not 100% decode — tools, prefill, and sampler waits eat the rest. Use 40% decode duty for a farm that is actually looping without a human in the chair:

400 tok/s × 0.40 × 86,400 s/day × 30.44 days = 421 million output tokens / month

Bishop’s mix costs $145.87 of Grok 4.6 API per million output tokens (because each million of output rides ~7.9M input and ~248M cache). Scale that:

“Bishop-session” = 1.23M output / 31 ≈ 39.7k output tokens, with that week’s cache/input ratio. Your loops will differ. If Flash is 2.1× more verbose, you finish fewer tasks per GPU-second, not fewer Grok-equivalent dollars — the Grok-eq column is priced at Grok rates for the same token mix. Flash list is 16.0× cheaper on that mix; “same tasks” is 11.9× (§7). Locally the tokens cost power.

Against the $300 subscription

A fully used Heavy month is maybe $5k–$8k of Grok 4.6 API. The 4× box at 24/7 is ~8–12 Heavy months of that value in one calendar month, or ~200 SuperGrok ($30) months. Electricity for 4× 600W + ~300W host ≈ 2.7 kW:

2.7 kW × 24 × 30.44 × $0.12/kWh ≈ $237/month  ·  at $0.20/kWh ≈ $394/month

So the local “subscription” is power plus amortization, not $300. $10k of Grok-equivalent tokens on the box costs a few hundred dollars of electricity, not $300 of xAI. Buying that same $10k of Grok-eq on OpenRouter Flash is $626 list / $313 promo — cheap vs Grok API, still ~10–16× the electricity bill. That is the whole argument for leaving the meter, and for not pretending OpenRouter is as cheap as owning the GPUs.

9. M5 Ultra 256GB — 1×, 4×, 6× vs the 4× 6000

Same Bishop ruler. Same 40% decode duty. Different silicon: Mac Studio M5 Ultra, 256 GB unified memory, 1.2 TB/s (Apple, 25 Aug 2026). 256GB is the SKU you can order today; 512GB follows in late October. Flash at 4-bit is a 200GB Unsloth GGUF / ~178GB MLX 4-bit. It fits. KV is the squeeze.

What actually fits on 256GB

Unsloth GGUF sizes 28 Aug 2026; PipeNetwork MLX PPL table (8-bit 334.1 GB / mixed-4/8 181.9 GB / 4-bit 177.6 GB). Unsloth’s 4-bit “162–210 GB total memory” band is why Q4 on 256GB is a 1–2 agent machine, not an 8-agent machine.

Decode: measured M3 Ultra, scaled to 1.2 TB/s

Nobody has published a warmed GLM-5.3-Flash decode curve on M5 Ultra yet — machines start arriving 22 Sep 2026. Two M3 Ultra 512GB numbers exist: omlx Q4e 24.1 tok/s (4k prompt), antirez ds4 Q4 35.5 tok/s short / 26.6 tok/s at ~12k. M5 Ultra bandwidth is 1.2 TB/s vs M3 Ultra 819 GB/s = 1.46×. Neural Accelerators (Apple’s 4.3× peak AI compute vs M3 Ultra) help prefill, not decode. Decode stays bandwidth-bound.

Agent C1 pin: 45 tok/s  ·  26.6 × 1.46 ≈ 39, plus a little Metal/MTP. High-concurrency aggregate per box: 70 tok/s (1.55× C1). NVIDIA SGLang got 1.9× C1→C8; Mac saturates the bus sooner.

Concurrency that still feels fast

Interactive pin on one 256GB Q4 replica: 2 agents. That keeps each stream in the 20–35 tok/s band — slower than hosted Flash (~50 tok/s) and slower than the 4× 6000 at C8 (~50 tok/s/stream), still usable. Four agents on one Q4 box drops you under ~18 tok/s/stream. That is overnight, not chat.

High-duty Grok-equivalent — the farm sheet

Same formula as §8: aggregate decode tok/s × 40% duty × 30.44 days, priced at $145.87 of Grok 4.6 API per million output tokens of the Bishop mix. That is $153.50 of Grok-eq per tok/s of aggregate decode. 1× high-concurrency uses 70 tok/s; replica clusters multiply the boxes.

Heavy column is emptied-month multiples using the $4.6k–$7.7k API-eq bracket from §6. Power is 180 W/Studio under inference (M5 Ultra community ~180–214 W peak; Apple’s last Ultra max was 270 W) at $0.12/kWh, vs 2.7 kW for the 4× 6000. Promo Flash is half the list column. 1× Ultra C1-only is the honest floor if Metal batching does not show up.

The X chart — $300 vs one Ultra vs 2×/4× 6000

Same ruler, six rows, the version made to post. Token-max Heavy and $300 of Flash buy about the same Grok-eq. $300 of flagship GLM-5.3 does not — it is $1.40/$4.40, 1.8× under Grok, not 16×. Pegged silicon is a different category: the box costs about one month of the Grok 4.6 API bill it replaces, then you pay watts.

PNG for X (1600×900, 2×)

$300 Flash = Bishop mix at list ($11.24/week → $4,794 Grok-eq). $300 GLM-5.3 flagship at $1.40/$0.26/$4.40 = $98.42/week → $547 Grok-eq. 2× 6000 is EXL3 C16 measured 336 tok/s × $153.46/tok/s-month. Power at $0.12/kWh. Current RTX PRO 6000 street ~$14–16k/card: 2× ≈ $30–37k vs $52k of Grok-eq/month; 4× ≈ $60–72k vs $61k; Ultra 256GB ~$10k vs $10.7k. One pegged month ≈ the hardware sticker in Grok 4.6 API dollars.

How to read the three invoices

• $300 Heavy is a cap, not a printer. Emptied, it is $5k–$8k of Grok 4.6 API. One M5 Ultra already clears that every month if you actually loop. The 4× 6000 and a 6× Ultra cluster clear it ~8–14 times.
• OpenRouter Flash has no cap and no GPU. It invoices the 1× Ultra’s month for $672 list, the 4× Ultra for $2,690, the 6× Ultra / 4× 6000 farm for ~$4k. That is the “I don’t want to own hardware yet” column. After 9 Sep 2026, budget list, not promo.
• Local is power plus the box. 1× Ultra is a Mac Studio bill (~$9.5k–$11k for 256GB) and ~$16/month. 4× Ultra is in the same capital neighborhood as 4× RTX PRO 6000, quieter, ~4× less electricity, ~70% of the token volume, same 8 interactive agents. 6× Ultra catches the 6000 farm on tokens and still sips power.

10. What I would actually run

1. Serve LibertAIDAI/GLM-5.3-Flash-NVFP4 with the 0xSero SGLang SM120 image, TP4, flashinfer_cutlass, MTP5, FP8 KV, graphs ≤ 8. Parsers: reasoning glm45, tools glm47.
2. Cap interactive agents at 8. Overnight loops at 16. Do not pass tiny max_tokens — max thinking will burn the budget inside <think> and return empty content.
3. Effort: low for mechanical edits, high for implement-and-test, max only when a Grok-class problem would have justified Grok. Default is max; that will inflate verbosity toward the AA 2.1× figure.
4. OpenRouter Flash as the overflow while the local image is compiling, and after 9 Sep 2026 budget list $0.15/$0.50 not the promo. Plan ~$626/month if you are going to do $10k of Grok-eq on the API, ~$3,840/month if you want the pegged-farm volume without the GPUs yet.
5. Keep one Grok 4.6 (or Opus) seat for plan, review, and the 10% of tasks where four AA points and token thrift matter. Spend the weekly pool on that, not on loops.
6. On M5 Ultra 256GB: Unsloth UD-Q4_K_XL or MLX mixed-4/8, llama.cpp / Unsloth Desktop / MLX. Cap interactive agents at 2 per box. Cluster with replicas (exo or just four API ports), not tensor-parallel Flash. Q3 only if you insist on 4 agents on one 256GB machine.

If the goal is maximum concurrent loops rather than nicest single-agent UX: two EXL3 TP2 replicas instead of one NVFP4 TP4 on the 4× 6000, or N Ultra replicas. Same idea either side — more endpoints, slower each stream.

11. Caveats

• xAI does not publish SuperGrok token quotas. Bishop’s week is one $30 account, one tool, one week. Heavy is not proven to be 10×.
• Subscription pool ≠ API invoice. Cache weighting inside the consumer meter is unknown. I priced the recorded mix at API rates; that is Grok-equivalent dollars, not what xAI billed.
• Flash is more verbose on AA (150M vs 72M). Loops may need more GPU-seconds per finished PR. The $10k column is token-mix equivalent, not “equal merged PRs.”
• Harnesses dominate coding scores. Agents on Rails used different products (OpenCode vs Grok Build). Flash ≠ GLM-5.3 flagship.
• SM120 is picky. CuteDSL MoE will not start. Use the locked image + flashinfer_cutlass.
• Ada 48 GB ×4 is a different brief. Do not paste these concurrency or $10k numbers onto 192 GB.
• Power and utilization are the real local bill. A box that sits at 5% duty while you sleep is not a $61k printer.
• OpenRouter Flash list is 16× Grok API, not 16× SuperGrok. The $30/$300 subscriptions are cheaper per Grok-dollar than Flash list when you fill them. Flash wins on the cap, not on unit price (except during the 50% promo).
• M5 Ultra Flash tok/s is scaled, not measured. C1 45 / aggregate 70 is M3 Ultra Q4 (24–36 tok/s) × 1.46 bandwidth, not a 22 Sep lab curve. If Metal+MTP lands closer to 60 C1, the Grok-eq column moves linearly.
• 256GB Q4 is KV-tight. Do not paste the 4× 6000’s “8 interactive on one replica” onto one Ultra. That 8 is four (or six) Macs, or one Blackwell node.
• Replica ≠ Apple’s 3× cluster claim. The 3× is tensor-parallel for models that do not fit on one box. Using it on Flash trades agent slots for one faster stream.

12. Sources

• Artificial Analysis — GLM-5.3-Flash (Index 57, $0.09/task, 150M Index output tokens)
• Artificial Analysis — Grok 4.6 (high) (Index 61, $0.94/task, $2/$6, 72M Index output)
• AA comparison page (blended $0.10 vs $1.35 / 1M)
• xAI docs — Grok 4.6 pricing
• Z.ai pricing — GLM-5.3 $1.40 / $0.26 cache / $4.40; Flash list $0.15 / $0.03 / $0.50
• OpenRouter — z-ai/glm-5.3-flash (promo $0.075/$0.25)
• Unsloth — GLM-5.3-Flash local / quant table
• 0xSero — NVFP4 SGLang on 4× RTX PRO 6000
• tpurtell — EXL3 4bpw on 2× RTX PRO 6000
• Ben Bishop — I finally hit the SuperGrok limit
• Agents on Rails — Grok 4.6 vs GLM 5.3
• VentureBeat — Flash vs Grok cost/intelligence
• Apple Newsroom — M5 Ultra Mac Studio (1.2 TB/s, 256/512GB, TB5 RDMA, 4-node 3× claim)
• PipeNetwork — GLM-5.3-Flash MLX quants (8/6/mixed-4/8/4-bit sizes + PPL)
• omlx PR #3184 — M3 Ultra-class Q4e 24.1 tok/s decode, 179.5 GiB footprint
• antirez ds4 — M3 Ultra 512GB Q4 35.5 / 26.6 tok/s
• EXO Labs — 4× M5 Ultra ~4.8 TB/s aggregate BW
• Related here: Grok 4.5 vs Opus 5, Cooking Qwen 3.8 27B, Mac Studio memory roadmap