Frontier model architecture is becoming a memory-systems problem

the dimsum editorial — Sun, 30 Aug 2026 00:00:00 GMT

Week of August 24–30, 2026 · Issue 1.1 (corrected 2026-08-30 — see Corrections)

The Week in One Sentence

Three frontier-scale open-weight models shipped within five days — Tencent’s Hy4 preview, Alibaba’s Qwen3.8-Flash-Next, and Z.ai’s GLM-5.3-Flash (after a record-breaking week in disguise as “Ox Alpha”) — and all three bet on the same architectural hand: sparse or linear attention hybrids plus a native multi-token-prediction layer for speculative decoding.

The Big Story: Tencent open-sources Hy4 preview — 770B parameters, Apache 2.0, and sparse attention goes mainstream

What happened. On August 28, Tencent released and open-sourced Hy4 preview, a 770B-total / 49B-active Mixture-of-Experts model with a 1M-token context window, under Apache 2.0, with both BF16 and FP8 checkpoints on Hugging Face, ModelScope, GitCode, and CNB. The full checkpoint is ~1.56 TB (779,960,992,733 parameters) across 78 layers (model card). This is Tencent’s flagship-class model going straight to open weights — the same week its two closest competitors shipped their own open previews (see Elsewhere).

Under the hood. The model card is unusually specific, and the architecture reads like a synthesis of the last nine months of Chinese frontier research:

Attention: “Gated DeepSeek Sparse Attention (Gated DSA) with IndexCache for cross-layer sparse index reuse” — the model card explicitly cites DeepSeek’s DSA paper (arXiv:2512.02556) and a GLM paper (arXiv:2603.12201) as design references. Structural details: 64 heads, query compression to 2048 dims, KV compressed to 512 dims, a 32-head indexer (128-dim) with top-k 2048.
MoE: 256 routed experts + 1 shared, top-8 routed per token, MoE on layers 2–78 with a dense layer 1.
Residual: “identity Hyper-Connections” (iHC) with 4 residual streams — in the same family as Kimi K3’s Attention Residuals and GLM-5.3-Flash’s Manifold-Constrained Hyper-Connections.
Native MTP: a built-in 10B/0.7B multi-token-prediction layer for speculative decoding, served by default in both vLLM and SGLang recipes (3 draft tokens).

What the evidence says. Two tiers, kept deliberately separate:

Vendor-reported (not independently verified): an internal blind evaluation — 163 domain experts, 203 engineering tasks — scored Hy4 preview 2.99/4 versus Kimi K3 at 2.94 and GLM-5.3 at 2.92 (Tencent announcement). Model-card benchmarks: GPQA Diamond 92.3, SWE-bench Multilingual 82.9, SWE-bench_Pro 65.7, Deep SWE 64.3. The announcement also claims the model “participated in its own training” via a recursive improvement loop and autonomously optimized its inference operators for a 31.8% end-to-end throughput gain — a striking claim with no external evidence; treat as marketing-grade until reproduced.

Independent and community evidence: still thin, honestly. The r/LocalLLaMA weight-drop thread largely amplifies Tencent’s own blind-eval numbers rather than re-running them. A community GGUF quantization reportedly compresses the ~1.56 TB checkpoint to ~200 GB with ~98% performance retained — unverified, but the official path exists via Tencent’s AngelSlim toolkit (see Repo Radar). BenchLM ranks it #7 of 228 at 79.16, but marks that score “Estimated.”

Worth crediting: Tencent self-flags real weaknesses in the model card — the model “spends longer than necessary reasoning” and over-verifies its own work, and both pre-training and post-training “have real headroom left.” That candor is a useful data point itself: this is a mid-training-cycle checkpoint, not a polished flagship.

Engineer reaction and deployment surface. Same-day serving support is the real story for practitioners: prebuilt vLLM image (vllm/vllm-openai:hy4-preview) with a custom FLASHMLA_SPARSE attention backend and hy_v4 tool-call/reasoning parsers, plus a multi-arch (x86 + Arm) SGLang image with NEXTN speculation. Both recipes assume 8-way tensor parallelism minimum for the FP8 variant. API pricing: $0.834/M input, $2.501/M output, $0.042/M cache hits (Tencent; the cache-hit line matters more than the headline price for agentic workloads — see My Read).

Why this matters. DSA-style sparse attention and native MTP have graduated from “a DeepSeek paper” to “the default recipe copied by at least five major labs” (DeepSeek, Qwen, Tencent, Meituan, Z.ai — all documented in this issue). Hy4 is also strong evidence that Apache-2.0 frontier weights are now a competitive strategy, not a gesture: the only independent evaluation I found this month (Aikido’s, below) now treats Chinese models as defaults rather than add-ons.

What I would test.

Speculative decoding economics: FP8 @ TP8, MTP on vs off — measure draft acceptance rate and tokens/sec at 1K/64K/512K context. The MTP layer is 0.7B active; if acceptance is near the ~3.1 mean length Meituan reports for LSA models, decode throughput should move materially.
The overshoot tax: run a fixed coding-agent task battery at default (high) reasoning effort vs reasoning_effort: "no_think" and count tokens. If over-verification is real, the cost delta is the story.
IndexCache at distance: needle-retrieval and re-ranking tasks at 256K–1M, watching for the cross-layer index reuse degrading (Meituan’s paper, below, found cross-layer reuse needs distillation to stay safe — N=4 without it collapsed their 128K needle score to 70%).

A note on Anthropic model names in this issue. Three different vendors’ materials reference three different Claude generations: Opus 4.6 Max appears in Qwen’s benchmark table, Claude Opus 4.8 in Z.ai’s positioning claim, and Opus 5 in Aikido’s test pool. The spread reflects the sources’ vintage, not typos — and it means cross-section score comparisons are not apples-to-apples.

Elsewhere in AI Engineering

GLM-5.3-Flash — the model that spent its record-breaking launch week anonymous, on Chinese silicon — Worth Testing

What happened. On August 20, a free, unattributed model called “Ox Alpha” appeared on OpenRouter and OpenCode — no owner, no model card, 1M-token context, text/image/video input (Linas’s Newsletter). Six days later it was the most-used model on OpenRouter, having processed ~23 trillion tokens — the biggest launch in the platform’s history at roughly 2.3× the volume of the next model, and the end of DeepSeek’s 56-day run atop OpenCode (Linas). On August 26, Bloomberg’s confirmation surfaced what the community suspected: Ox Alpha was Z.ai’s GLM-5.3-Flash, and the weights landed on Hugging Face under MIT that same evening — the HF repository was created August 25 (Linas; HF metadata). It’s 321B total / 18B active, natively FP8, ~328 GB (model card), with 346K downloads in its first days.

Technical signal. First natively multimodal GLM-5 (image/video/audio in), first GLM with a hybrid sparse + linear attention stack and “Manifold-Constrained Hyper-Connections,” trained on a 30T-token multimodal corpus; backing paper is arXiv:2602.15763 (per the model card). Z.ai’s launch materials describe an “IndexPool” that compresses groups of indexer key vectors to hold down latency and memory at million-token context — a fifth team attacking the indexer, though I have to flag it: the mechanism is not documented in the HF model card, and I could not verify it from a citable primary. The citable relayed claims are ~3× less attention compute and a 4.4× smaller KV cache than GLM-5.3 at 1M context (Linas, relaying Z.ai). Vendor benchmarks: Terminal-Bench 2.1 at 84.3, DeepSWE 63.4 at 400K context.

The silicon detail is the part with the longest shadow: Zhipu claims the entire anonymous launch week was served on a cluster of roughly 100,000 Chinese-made AI chips, with no NVIDIA hardware involved (Linas; corroborated as reporting by SCMP). That is a vendor claim relayed through press, applying to inference “at production quality” — not training, and not independently audited. But it is the first same-week partial answer to the open question in the Ascend item below.

Why it matters. The model card’s own benchmarks expose exactly where long-context claims should be stress-tested: ExtractBench collapses from 96.3 on short documents to 27.83 on long ones, and layout parsing sits at 41.78. That’s the difference between a leaderboard context length and a usable one. The stated positioning — GLM-5.2 capability “at one-tenth the price” — is vendor framing; the MIT license and the OpenRouter usage data are the facts.

Go deeper: HF model card · Linas’s Ox Alpha timeline · SCMP on the reveal

Qwen3.8-Flash-Next — Alibaba open-sources a live preview of the Qwen4 architecture — Worth Testing

What happened. Open weights landed August 24–26 (HF metadata says 2026-08-24; the Qwen blog announced August 26, 23:00 Beijing). This follows the Qwen3.8-Max 2.4T-A95B weights on August 12 and the 27B on August 14 — the first time Qwen shipped a Max-tier model as open weights.

Technical signal. The model card is a spec sheet for where frontier efficiency architecture is going. Total ~180B parameters in the repo, but the composition is the interesting part: a 125B/6B-active LM, plus a 51B-parameter n-gram embedding table (20M bigram/trigram entries consulted at layer 2), plus a 4B MTP layer. Layer layout is 12 repeats of (3× Gated DeltaNet linear-attention blocks → 1× QSA block): “Qwen Sparse Attention” operates at the micro-block level, not individual tokens, with a selection budget the card states verbatim as “512 blocks or 2048 tokens” — the same budget in two units. Block size is not stated on the card; the arithmetic implies 4-token micro-blocks (2048 ÷ 512), which is my inference, not their text. An MQA indexer (4 query heads, 1 shared key head) drives selection. 512 experts, 10 routed + 1 shared. Training used Muon + AdamW split by weight category with no batch-size warmup, justified by refitted scaling laws — a notable optimizer confession. Context is 262K native, 1M via YaRN.

Vendor benchmarks (self-reported): DeepSWE 1.1 at 58.7 with 6B active parameters — versus 54.4 for DeepSeek-V4-Flash-0731 — and SWE-bench Pro 62.5, ahead of Qwen3.8-27B (61.7), Qwen3.7-Plus (55.8), DeepSeek-V4-Flash (56.0), and Claude-Opus-4.6 Max (53.4) on their harness (model card). GPQA-D 91.7, AndroidWorld 84.5.

Why it matters. A 6B-active model matching 50B-plus-class agentic performance would rewrite cost assumptions — if it holds off the vendor’s harness. Caveats worth flagging: the license is qwen-community-1.0, not Apache (read it before commercial deployment); the card admits static YaRN may hurt short-text quality, and low reasoning-effort settings can increase total agent tokens. One more sharp edge, flagged by a reader and unverified by me (the hosted model’s card isn’t publicly accessible): the hosted Qwen3.8-Flash and the downloadable Flash-Next weights are reportedly distinct artifacts diverging on license, default context, and built-in tools. Until Qwen documents the mapping, treat the open preview as an architecture demo, not a mirror of the hosted model. Worth Verifying. Community reception is running hot in the r/LocalLLaMA megathread, with 135 community quantizations already published.

Go deeper: HF model card · Qwen blog · QwenLM/Qwen3.8 repo

Aikido’s independent CVE benchmark — the best third-party read all month on the new Chinese models — Worth Reading

What happened. Security firm Aikido ran 10 models against 32 recently-disclosed CVEs, 3 runs each (~11.7B tokens), 30-turn agents, no internet, frozen harness (Aikido, Aug 21). This is the only genuinely independent evaluation I found covering this month’s releases.

Technical signal. Pooled recall: DeepSeek V4 Pro (0813) found 28/32 — best of all ten models — for ~$295 across three runs, versus $450–590 for a single pass of Opus 5 or Grok 4.6 (26/32 each) or Sol (25/32). DeepSeek V4 Flash hit 24/32 for $108 total — matching Grok 4.6’s best individual pass at under a quarter of the cost. Kimi K3: 25/32 with the best open-weight precision (92.3%). Qwen3.8-Max: 26/32, but “CVE déjà vu” — in 95 of 96 traces it burned turns re-finding already-patched CVEs from training data. GLM-5.3 final: 25/32 with the highest pass-at-1 consistency among open models (18/32 across runs).

The counter-evidence deserves equal billing, because it’s where the closed frontier still wins: Grok 4.6 found 21/32 in all three runs — the most consistent model tested — and Opus 5’s strongest single pass (25/32) beat every open model’s first run. Cheap open-weight coverage wins on recall-per-dollar; run-to-run stability is still a frontier moat.

Why it matters. The caveats are the finding: DeepSeek models produce far more candidate findings (cheap recall, expensive triage), only 10 of V4 Pro’s 28 CVEs were found in every run (high variance), and Aikido’s own verdict on “can I swap my frontier model for an open Chinese one” is “Yesn’t” — the harness matters more than the model. This is the correct mental model for the whole open-weight surge: pooled cheap runs beat single expensive passes on coverage, and push cost downstream into filtering.

Go deeper: Aikido benchmark writeup. Pricing context for the cost math — DeepSeek’s V4 lineup moved to peak/off-peak rates on August 16: V4-Pro lists at $1.32/M input (cache miss) and $3.96/M output at peak, half that off-peak, with cache hits at $0.044/M peak; “peak” means 01:00–04:00 and 06:00–10:00 UTC, weekdays (rate card, GA notice; Reuters on the GA).

Huawei’s Ascend 950DT pulls its cloud debut into August — Worth Watching

What happened. Huawei confirmed the Ascend 950DT will debut on Huawei Cloud in August, ahead of its original Q4 2026 roadmap slot (HuaweiCentral; VP Chen Lin via WinBuzzer; pull-forward first reported by TrendForce).

Technical signal (all vendor/analyst claims, none independently verified): H200-class performance with in-house-developed HBM (SCMP); the Atlas 950 SuperPoD architecture connects up to 8,192 950DT NPUs (Huawei Connect 2025 keynote). TrendForce’s note that DeepSeek V4.2 might be an early adopter is a rumor, full stop.

Why it matters. Sparse-attention, MTP-heavy architectures like this week’s three releases are memory-bandwidth machines — which is exactly the axis (self-developed HBM) Huawei claims as its differentiator. And the first partial evidence arrived the same week, from a competitor’s launch: Zhipu’s claim that GLM-5.3-Flash’s record OpenRouter week ran on ~100,000 domestic accelerators with no NVIDIA hardware (see the GLM item — vendor-claimed, unaudited). One vendor’s launch claim does not settle whether Chinese silicon can serve these architectures at production quality, but it moves the question from “can they?” to “who will verify it first?”

Go deeper: Ascend roadmap keynote · TrendForce analysis

Research Radar

LongCat Sparse Attention: Taming the Lightning via Streaming-aware Hierarchical Cross-Layer Indexing

arXiv:2608.01662 — Meituan LongCat Team (14 authors; v2 Aug 4, 2026). Weights: LongCat-Flash-Lite-Sparse 69B-A3B.

Problem. DeepSeek Sparse Attention made long context affordable but introduced a new bottleneck: the Lightning Indexer costs O(L²) and its selections scatter memory access — the paper measures DSA’s scattered gathers at only ~4.5% of peak HBM bandwidth, with the indexer consuming 90% of per-layer decode time at 1M context.
Core idea. Three orthogonal fixes: streaming-aware indexing (re-lay KV entries into contiguous, coalesced blocks), cross-layer indexing (compute an index once, reuse across N consecutive layers, made safe by cross-layer distillation), and hierarchical indexing (coarse-to-fine candidate narrowing). This is implementation refinement, not a new attention theory — and the paper is honest that its novelty is hardware-algorithm co-design.
Evidence (vendor-run, but unusually well-ablated). Training speed 1.53–1.61× over DSA per attention layer; end-to-end inference 1.42–3.60× prefill / 1.25–1.40× decode. Quality parity: RULER-style recall 98.63 (LSA) vs 98.83 (full attention) at 69B, validated again at 560B-A27B. LongCat-2.0 (1.6T-A48B) was trained on it. The ablations are the best part: hierarchical indexing is slower below 256K (0.79–0.82×); cross-layer reuse without distillation collapses 128K needle-in-a-haystack from 96% to 70%; MTP acceptance is unaffected (3.11 vs 3.15).
Limitations. LSA cuts compute, not KV footprint — every token still stores a KV entry, so aggregate memory pressure is unchanged (authors point to CLA / DeepSeek-V4’s CSA as complements). Hierarchical indexing slightly hurts some agentic/code tasks (SWE-Bench Verified 68.20 → 65.20).
Why I bookmarked it. It’s the first paper I’ve read that treats the indexer as the primary scaling enemy — the exact component Tencent’s IndexCache, Qwen’s QSA, and (per launch materials) GLM’s IndexPool are also optimizing. Read alongside those model cards, it explains where the next efficiency war is being fought.
Read this if… you serve or train long-context models, or you want to understand why every architecture in this issue looks the way it does.

FlashPrefill V2: Block-Sparse Prefill Attention for Long-Context LLM Serving

arXiv:2608.19758 — Qihang Fan, Huaibo Huang, Zhiying Wu, Bingning Wang, Ran He (Tencent Hunyuan × CAS lineage, per V1’s author list); Aug 20, 2026. V1 code: github.com/qhfan/FlashPrefill.

Problem. Prefill, not decode, is the wall for long-context serving — quadratic attention at a compute-bound stage.
Core idea. A production-grade block-sparse prefill kernel: a mean-correction term that substitutes pooled statistics of pruned blocks into the softmax (recovering quality at aggressive sparsity), plus a Hopper-aligned kernel (PackGQA tiling, warp specialization, pingpong pipelines, FP8 with per-tensor scales) integrated into SGLang as a real attention backend with paged KV and continuous batching.
Evidence (vendor-run). On H20 GPUs — the China-market NVIDIA part, bandwidth-rich and compute-poor, which makes this hardware choice itself a signal: up to 47.26× (FP8) / 27.19× (BF16) over FlashAttention-2 at 128K, 30.49× over an FA3/4-aligned dense baseline, 2.1–4.8× end-to-end TTFT in SGLang. The mean correction keeps FP8 within ~1 point of full attention where naive sparsity loses 6.2 points.
Limitations. Decode falls back to dense (single query token can’t exploit block sparsity); chunked prefill erodes gains (P50 speedup drops 1.9× → 1.6× at 8K chunks); at 4K contexts it’s merely at parity. V2 code does not appear to be released yet — only V1’s repo exists.
Why I bookmarked it. The mean-correction trick is a genuinely reusable idea for anyone building approximate attention, and the H20 targeting tells you which hardware fleet this is actually for.
Read this if… you build inference infrastructure or want one paper that connects sparsity research to real serving-stack engineering.

Kimi K3: Open Frontier Intelligence (the report everyone’s still benchmarking against)

arXiv:2607.24653 — Kimi Team; weights July 27, v2 Aug 7, 2026.

Problem. Frontier capability at open weights, at 2.8T scale.
Core idea. Kimi Delta Attention (a gated-delta linear-attention variant) + Attention Residuals; “Stable LatentMoE” routing 16 of 896 experts; ~2.5× scaling efficiency over K2 (vendor claim); post-training centered on million-token agentic RL with persistent rollout/sandbox state.
Evidence. Vendor evaluation suite shows frontier-level long-horizon coding/agentic results; the paper itself concedes it “still trails” the top proprietary models. The best independent corroboration this month is Aikido’s 25/32 recall at 92.3% precision — the highest-precision open model in their pool.
Limitations. Self-reported margins. On licensing — corrected from v1.0, see Corrections — the weights carry a bespoke Kimi K3 License (tagged license: other on HF), not a Creative Commons term: it permits use, modification, distribution, sublicensing, and sale, with a separate Moonshot agreement required only for MaaS operators above $20M revenue over any consecutive 12 months, and on-screen “Kimi K3” credit required for commercial products above 100M monthly active users or $20M monthly revenue; internal use and Moonshot’s own channels are exempt (LICENSE file). That is a permissive-with-thresholds template that closely mirrors Qwen’s community-license structure — so the real licensing story across these releases is convergence on a common bespoke pattern, not divergence. The decision axis for readers is reading each model’s thresholds, not avoiding commercial use.
Read this if… you need the reference architecture for the model that Hy4, Qwen, and half of August’s leaderboards are being compared against — and read the LICENSE before productizing, not this newsletter’s memory of it.

Repo Radar

Tencent-Hunyuan/Hy4-preview

What’s actually in it: almost nothing — and that’s worth knowing precisely. Five commits, two directories (assets/, finetune/), plus README and LICENSE. Benchmarks ship as JPGs. No eval harness, no training code, no requirements file.
What you can run: the documented vLLM/SGLang Docker paths (FP8, TP≥8, MTP speculative decoding) and a finetuning pipeline referenced via finetune/README.md (I did not execute it; treat as documented-not-verified).
What’s missing: any way to reproduce the 2.99 blind-eval score, a hardware requirements section, and anything beyond inference manifests. The gap between “frontier open weights” and “repo contents” is entirely bridged by upstream vLLM/SGLang support.
Why open it: as the canonical deployment reference — the exact vLLM flags (--attention-backend FLASHMLA_SPARSE, --tool-call-parser hy_v4, MTP config) are the valuable contents.

QwenLM/Qwen3.8

What’s actually in it: a docs-only landing repo — README and LICENSE, 11 commits, zero source files. Training is explicitly delegated to Unsloth/Swift/Llama-Factory; inference to transformers/vLLM/SGLang CLIs.
What you can run: nothing from here directly; use it as the release ledger. Its News section is the authoritative weight-release timeline (Qwen3.8-2.4T-A95B on Aug 12, 27B on Aug 14) and corrects fuzzier secondary reporting on launch dates.
What’s missing: code, releases/tags, and a license clarification — the repo is Apache-2.0, but the README defers weight licensing to the model card, where Flash-Next carries qwen-community-1.0. That split deserves attention before commercial use.
Why open it: the fastest primary-source answer to “which Qwen weights exist, and since when.”

Tencent/AngelSlim

What’s actually in it: a real, maintained compression toolkit (docs) covering quantization, quantization-aware distillation (a Megatron-Core “MCoreQAD” backend for distributed QAD), speculative decoding, sparse attention, token compression, and even diffusion-model compression, with guides for Hunyuan, DeepSeek, and Qwen families. (Inspection depth: README and docs landing pages, not a full code audit.)
What you can run: per-model quantization recipes — e.g., the documented Qwen3-Omni FP8 static/dynamic workflows — and it’s the officially referenced compression path for squeezing Hy4’s ~1.56 TB checkpoint onto fewer GPUs.
What’s missing/incomplete: the Hy4-specific recipes postdate my inspection; Tencent Cloud’s headline claim (1.8B → 2-bit at ~4% accuracy loss) is vendor-reported without an independent reproduction I could find.
Why open it: with three 300B–770B open models released this week, compression tooling is suddenly the practical bottleneck for actually deploying any of them, and this is the most complete first-party toolkit in the ecosystem.

My Read on the Week

(Synthesis and interpretation — not reported fact.)

1. The indexer is the new bottleneck, and everyone now knows it. Five independently-developed systems — DeepSeek’s DSA, Qwen’s QSA, Tencent’s Gated DSA with IndexCache, Meituan’s LSA, and (per launch materials, not the model card) Z.ai’s IndexPool — converged on the same thesis: sparse attention won, so now optimize the thing that selects the sparsity. Meituan’s profiling (indexer eating 90% of decode time at 1M context, gathers at 4.5% of peak bandwidth) explains why Tencent ships cross-layer index reuse, Qwen moved selection up to micro-blocks, and Z.ai is compressing indexer keys. When this many teams attack the same sub-component in one month, that sub-component is where next year’s throughput gains live.

2. Open-weight releases have become infrastructure events, and the “repo” is now a manifest. None of this week’s three flagship repos contains meaningful code — the engineering artifact is the serving-stack support: same-day vLLM/SGLang images, custom parsers, FP8 checkpoints, MTP recipes, compression tooling. The practical evaluation question for an open model has shifted from “is it open?” to “how fast did the serving frameworks land, and does the cache-hit price line work for my agent loop?” The pricing surface is converging on agentic economics: Hy4’s $0.042/M cache-hit rate, DeepSeek’s peak/off-peak card ($0.022/M off-peak cache hits on V4-Pro), and Qwen’s 6B-active bet all compete on cost per completed agent task, not cost per token. The OpenRouter numbers make the same point from the demand side — ~23T tokens in six days went to whichever model made agent loops cheapest. And the sharpest unresolved wrinkle for that argument is the Qwen split flagged above: if the hosted Qwen3.8-Flash and the open Flash-Next weights really are different artifacts, then “open preview” and “what you’re paying for” need to be compared separately, per vendor, every time.

3. Verification is lagging capability — and this week, usage ran ahead of both. Every headline number this week is vendor-run: Tencent’s blind eval, Qwen’s benchmark table, Z.ai’s positioning claims, Zhipu’s 100K-domestic-chip serving claim. The only independent instrument I found (Aikido’s) says the open models are better than expected on coverage, worse on precision, and inconsistent run-to-run — not a reason to skip them, but a reason to budget for triage. The Ox Alpha launch is the phenomenon in its purest form: the market routed 23 trillion tokens to a model nobody had benchmarked, under a name nobody owned, and the identity reveal came after the usage record. Community threads also repeated vendor numbers as if they were independent confirmations; they aren’t. The reproduction layer for 300B–770B-class models is GPU-expensive, and it shows.

What I’d Watch Next

GLM-5.5. Media (CGTN, AIBase) have reported an August window for a 1T-plus “architecture leap,” but Z.ai has confirmed nothing (rumor roundup). Given Z.ai shipped GLM-5.3-Flash this week under MIT, the license and sparse-attention details of a true GLM-5.5 would be a direct comparable to Hy4.
Independent numbers on domestic silicon. The Ascend 950DT’s August Huawei Cloud debut was vendor-confirmed, and Zhipu’s ~100K-chip serving claim is the first (unaudited) production-scale data point. First third-party throughput measurement on sparse-attention + MTP workloads is the moment the bandwidth story gets tested — watch for OpenRouter-adjacent latency data and any Zhipu disclosure with verifiable detail.
Hy4’s official release. Tencent says the next batch is coming soon; the specific thing to watch is whether the reasoning-overshoot/over-verification behavior survives post-training, and whether any reproducible eval harness ships with it.

One Thing I’d Experiment With This Week

Replicate the “cheap coverage vs. expensive precision” tradeoff on your own bug-finding workload. Aikido’s data (methodology) supports a precise claim: three DeepSeek V4 Pro runs (~$295 total) reached 28/32 pooled recall, beating single $450–590 passes of Opus 5 and Grok 4.6 (26/32) — while three V4 Flash runs ($108) hit 24/32, matching Grok 4.6’s best individual pass at under a quarter of the cost. Note the asymmetry: the pooled-cheap-beats-single-expensive result belongs to Pro; Flash’s result is “equivalent coverage to a frontier pass, much cheaper,” not a win. Test whether the Pro result holds on code you own:

Setup: 20–30 bugs with known ground truth — recent CVEs in your dependency tree, or seeded defects in a frozen repo snapshot. Same harness, same turn budget (Aikido used 30), no internet, three runs per model.
Conditions: one frontier closed model, single pass (the consistency baseline); three passes of DeepSeek V4 Pro (the coverage arm); three passes of V4 Flash (the budget arm); optionally one pass of Hy4 at low reasoning effort to probe the overshoot tax.
Measure: pooled recall per dollar, precision (accepted findings / candidates raised — this is where Aikido says open models bleed), cross-run consistency (Jaccard overlap of found-bug sets — V4 Pro’s was only 10/32 stable, versus Grok’s 21/32), and median turns consumed. The decision output is a number: your triage cost per additional true positive over the frontier single-pass baseline. If Pro’s pooled recall clears the baseline at lower cost after triage labor, the open-model pool wins; if the false-positive load eats the savings, you’ve quantified exactly why not.

Corrections

Issue 1.0 → 1.1, 2026-08-30. Reader feedback surfaced three material errors and several smaller ones; all load-bearing claims below were re-verified against primary sources before correcting.

Kimi K3 license (Research Radar) — wrong, and the analysis built on it was inverted. v1.0 stated the weights ship under CC BY-NC-ND and argued this showed “license divergence” across Chinese labs. The LICENSE file in the weight repo defines a bespoke Kimi K3 License: commercial use, modification, and sale are permitted, with thresholds (>$20M/12-month MaaS revenue → separate agreement; >100M MAU or >$20M monthly revenue → on-screen credit). Corrected, and the takeaway rewritten as convergence on a permissive-with-thresholds template. Root cause: a carryover assumption from earlier Kimi releases, not re-checked against the license artifact.
Closing experiment (One Thing I’d Experiment With) — model swapped in re-narration. v1.0 attributed the pooled-recall win (24/32 at $108) to V4 Flash and said it “beat” single frontier passes (25–26/32). 24 does not beat 25; Aikido’s actual finding is that Flash matched Grok 4.6’s best single pass at a quarter of the cost, while the beat-single-expensive result belongs to V4 Pro (28/32 at ~$295). Corrected throughout, experiment conditions updated. Root cause: numbers traveled two thousand words from their first correct use.
Aikido results (Elsewhere) — Sol’s score miscounted, counter-evidence under-reported. v1.0 wrote “Opus 5 / Grok 4.6 / Sol, which found 26/32”; Sol found 25/32. Added the omitted counter-evidence: Grok 4.6’s 21/32 all-three-runs consistency (most consistent model tested) and Opus 5’s strongest single pass (25/32). (Aikido)
QSA block size (Elsewhere) — unverified detail introduced. v1.0 described “512-token blocks,” which contradicts the card’s stated budget of “512 blocks or 2048 tokens.” The card never states a block size; the two budget figures imply 4-token micro-blocks (inference, now labeled as such). (HF model card)
Internal consistency. Standardized checkpoint size to ~1.56 TB (was “1.5 TB”/“1.56 TB” in different sections); reconciled “every serious open-weight evaluation this month” with “the only independent instrument I found” (single formulation now); applied the weights-vs-announcement date distinction to GLM-5.3-Flash (weights Aug 25, reveal Aug 26), as v1.0 had done for Qwen but not GLM; defined DeepSeek’s peak/off-peak pricing at first use instead of referencing it undefined.
Material omissions, added. The Ox Alpha stealth launch, OpenRouter usage record (~23T tokens), and Zhipu’s domestic-silicon serving claim — which connect the GLM item to the Ascend item and to this issue’s verification thesis. GLM’s “IndexPool” is included but explicitly flagged as launch-material-only (absent from the model card; no citable primary). The Qwen hosted-vs-weights divergence is included but explicitly flagged unverified.

Found an error? Reply and it goes here, dated, with the correction. The working claims ledger behind this issue is maintained alongside it in the repository at research/2026-08-30/claim-ledger.md.

All vendor-reported figures are labeled as such; if independent evidence doesn’t exist yet, that’s stated rather than papered over.

References

Fan, Qihang, Huaibo Huang, Zhiying Wu, Bingning Wang, and Ran He. 2026. “FlashPrefill V2: Block-Sparse Prefill Attention for Long-Context LLM Serving.” arXiv. https://arxiv.org/abs/2608.19758.

Kimi Team, Moonshot AI. 2026. “Kimi K3: Open Frontier Intelligence.” arXiv. https://arxiv.org/abs/2607.24653.

LongCat Team, Meituan. 2026. “LongCat Sparse Attention: Taming the Lightning via Streaming-Aware Hierarchical Cross-Layer Indexing.” arXiv. https://arxiv.org/abs/2608.01662.

Citation

BibTeX citation:

@online{dimsum_editorial2026,
  author = {dimsum editorial, the},
  title = {Frontier Model Architecture Is Becoming a Memory-Systems
    Problem},
  date = {2026-08-30},
  url = {https://chiragsehra.gitlab.io/thedimsumnews/issues/2026-08-30/},
  langid = {en}
}

For attribution, please cite this work as:

dimsum editorial, the. 2026. “Frontier Model Architecture Is Becoming a Memory-Systems Problem.” August 30. https://chiragsehra.gitlab.io/thedimsumnews/issues/2026-08-30/.