AI research wiki
October 17, 2026 · daily digest

cere-bro | 2026-10-17

cere-bro | 2026-10-17

Today's savings come from giving the expensive part less to do. Three routing papers let a cheap model draft an agent's steps and call the frontier model only to review or rescue them, with up to 62% lower cost. A production study finds that on B300s a remote KV-cache hit is slower than recomputing the prompt below about 17K tokens. Virtual Head Attention serves with two KV heads and still beats GQA and MLA. NVIDIA ships a looped 4B model whose extra compute adds no cache. On the industry side, Microsoft published a rare training-efficiency number (21% MFU on 16,000 GB200s), Modal tripled its valuation in five months, and banks started blocking outside agents.

🎯 Today's 5 for you
  1. ReadSpecAgent, EdgeWise and LEASH: the cheap model works, the frontier model reviews. These papers route each step of an agent run, not just each request, and go below the turn-level routing from 10-16. LEASH (in both HF and Kurate) matches always-on Opus 5 at 19% lower cost. Your routing thread ([SpecAgent](https://arxiv.org/abs/2610.21463), [EdgeWise](https://arxiv.org/abs/2610.17560), [LEASH](https://arxiv.org/abs/2610.22280)).
  2. ReadWhen the KV cache is slower than the GPU. On B300s a remote cache hit took 0.88 s and recomputing took 0.31 s. A two-term formula says when caching pays, and the fixes cut p99 from 83 s to 0.67 s. A rare production KV cache number ([paper](https://arxiv.org/abs/2610.21500)).
  3. ReadVirtual Head Attention and PN-Mix: fewer KV heads, fewer key bits. VHA trains with extra linear mixes that fold away, so it serves as plain two-KV-head GQA. It beats MLA on a 30B MoE. PN-Mix stores keys at 2.26 bits by protecting the RoPE pairs that matter ([VHA](https://arxiv.org/abs/2610.17959), [PN-Mix](https://arxiv.org/abs/2610.19605)).
  4. SkimNVIDIA Dory1.0-4B and Tencent DSpine. A looped model that changes its loop count per task, keeps only the last loop's cache and was pre-trained in 4-bit. Plus a parallel drafter that beats DFlash2 on acceptance length. Research from 10-13 to 10-16 shipped as checkpoints ([Dory](https://huggingface.co/nvidia/NVIDIA-Nemotron-Labs-Dory1.0-4B-NVFP4), [DSpine](https://huggingface.co/tencent/Qwen3-8B-DSpine-b16)).
  5. TrackFlashMask-3 and MAI-Base-2's 21% MFU. One is a mask-aware Hopper kernel that skips sending KV blocks the mask makes useless (1.8-3.7x over ring context parallelism). The other is a public measure of how much of a GB200 fleet a frontier MoE actually uses. Skip the Minecraft hype threads ([FlashMask-3](https://arxiv.org/abs/2610.17901), [MAI-Base-2](https://microsoft.ai/news/frontier-pre-training-at-microsoft-ai/)).

TL;DR

Deep Dives

Weak model drafts, strong model reviews: SpecAgent, EdgeWise, LEASH

In a long agent run, the frontier model does not need to write every step. Reviewing a cheap model's steps keeps most of its quality at a fraction of the cost.

Source: HuggingFace Daily Papers; LEASH is cross-source confirmed (HF + Kurate) Links: SpecAgent · EdgeWise · LEASH · Wiki summary

Three triggers for the same escalation
The cheap model always works by default. Only what calls in the strong model differs.
flowchart LR
  T["Agent task<br/><small>long tool-use run</small>"] --> W["Weak model<br/><small>drafts every step</small>"]
  W --> G{"Trigger<br/><small>who decides escalation</small>"}
  G -->|SpecAgent| V["Strong reviewer<br/><small>one prefill, verdict</small>"]
  G -->|EdgeWise| D["Learned delegate<br/><small>RL-trained policy</small>"]
  G -->|LEASH| U["Latent uncertainty<br/><small>hidden-state match</small>"]
  V --> S["Strong model step<br/><small>repair or take over</small>"]
  D --> S
  U --> S
  classDef input fill:#d0ebff,stroke:#1971c2,color:#1b1b1b,stroke-width:2px
  classDef core fill:#e5dbff,stroke:#6741d9,color:#1b1b1b,stroke-width:2px
  classDef loop fill:#fff3bf,stroke:#f08c00,color:#1b1b1b,stroke-width:2px
  class T input
  class W,S core
  class G,V,D,U loop
Blue is the task, purple is a model doing work, amber is the escalation decision.

What is it about? These are three ways to run a long agent task mostly on a small model and bring in a frontier model only when it is needed. They appeared on the same HF day. They differ only in what decides to escalate.

What problem does it solve? Until now, most agents ran one strong model on every tool call. Routers chose a model per request (classic routing), per session (Arena's Max router, 10-14) or per turn (Microsoft's Whose Turn, 10-16, which found switching up to the big model mid-session loses the prompt cache). None of these decide inside a turn which steps are routine.

What's the core novelty?

Key takeaways

Gaps in the study Nobody compares the three triggers on one benchmark. LEASH needs labeled past trajectories from the same environment, and it is untested on new task families. SpecAgent stops drafting at the first write action, so write-heavy tasks get less benefit.

Industrial implication This is the next layer for routing vendors and coding agents. Expect "draft with small, verify with large" as a setting in agent frameworks within two quarters. Prefill is cheap and cache-friendly, which also fits the 10-16 finding that moving up mid-session is the expensive direction.

Research angle Two open questions. First, LEASH's failure-memory match is a natural detector for the states where Reading Right, Acting Wrong (10-15) found errors cluster across 17 decision systems. Testing that link costs little. Second, Fewer Bits, More Tries (10-15) showed retrying a small model eight times can replace escalation on verifiable tasks. A combined policy would retry when a verifier exists and escalate when the step needs judgment. Nobody has built it.

→ Full summary

When the KV cache is slower than the GPU

On B300s, fetching a cached prompt from the shared remote tier took 0.88 s. Recomputing it took 0.31 s.

Source: HuggingFace Daily Papers Links: Paper · Wiki summary

A cache hit is only worth it above a bandwidth line and a length line
Below 17K tokens the fixed per-hit cost beats any network speed.
flowchart LR
  R["Request<br/><small>long prompt</small>"] --> L{"Lookup<br/><small>min over ranks</small>"}
  L -->|miss or short| C["Recompute<br/><small>0.31 s on B300</small>"]
  L -->|long hit| F["Remote tier<br/><small>sharded by rank</small>"]
  F --> A["Async load<br/><small>no collective stall</small>"]
  C --> P["Prefill done<br/><small>p99 0.67 s</small>"]
  A --> P
  F -.->|sync, unsharded| X["Queue blowup<br/><small>p99 83 s, GPU 7%</small>"]
  classDef input fill:#d0ebff,stroke:#1971c2,color:#1b1b1b,stroke-width:2px
  classDef core fill:#e5dbff,stroke:#6741d9,color:#1b1b1b,stroke-width:2px
  classDef loop fill:#fff3bf,stroke:#f08c00,color:#1b1b1b,stroke-width:2px
  classDef exit fill:#d3f9d8,stroke:#2f9e44,color:#1b1b1b,stroke-width:2px
  classDef err fill:#ffe3e3,stroke:#e03131,color:#1b1b1b,stroke-width:2px
  class R input
  class L loop
  class C,F,A core
  class P exit
  class X err
  linkStyle 6 stroke:#e03131,stroke-width:2px
Blue is input, amber the hit-or-recompute decision, purple the work, green the fixed result, red the failure before the fixes.

What is it about? Serving systems reuse the KV cache (the saved attention keys and values of a prompt) across requests to skip prefill. Many now back each engine's local cache with a remote tier shared by all engines. This paper measures that tier in a real deployment: GLM-5.3, an FP8 mixture-of-experts model with MLA (multi-head latent attention, which stores a compressed cache), on 8xB300 nodes. Prefill is split across 8 GPUs (context parallelism, PCP8).

What problem does it solve? Turning on the remote tier (LMCache with a Valkey store) left median time-to-first-token unchanged. But the 16K-token p99 jumped from 3.96 s to 17.3 s. On a replay with many cache hits, p99 reached 83 s while the GPUs sat 7% busy. The GPUs were waiting on the network.

What's the core novelty? A simple cost model. A hit costs a fixed engine overhead (T0 ≈ 0.33 s) plus the bytes divided by tier bandwidth. Recompute costs tokens divided by the GPU's prefill rate. So a hit only wins if the tier is faster than B* = sR (KV bytes per token times prefill tokens per second), which is 2.53 GB/s here. Because of T0, prompts under about 17K tokens never win at any bandwidth. Guided by this, the authors shard the MLA cache across the 8 ranks (with a proof that the lookup still finds the longest cached prefix). They run one remote server per rank, add async loading and fix three client bugs.

Key takeaways

Gaps in the study One model, and MLA's small cache makes the tier look better than it would for a GQA model with bigger caches. No comparison with RDMA-native stores like Mooncake or AMD's MoRI.

Industrial implication Every agent-serving stack that assumes "a cache hit is always a win" needs a minimum hit length. That threshold depends on the hardware and moves up with each GPU generation. Expect LMCache, Dynamo and SGLang to expose it as a config.

Research angle This contradicts the easy reading of galahad-kv (10-09), which found NVMe reload 2.8-4.3x faster than recompute on an H100. Both can be right because B* scales with the GPU's prefill rate. Storage-tier wins measured on Hopper do not carry over to Blackwell automatically. The open question is the agent case. Session-aware Dynamo (10-09) holds a waiting session's cache during tool calls. A hit-length threshold could decide which sessions are worth holding at all.

→ Full summary

Virtual Head Attention and PN-Mix: fewer KV heads, fewer key bits

VHA trains with extra mixing layers that fold away at inference. What gets served is a plain two-KV-head model that beats MLA.

Source: HuggingFace Daily Papers Links: VHA · PN-Mix · Wiki summary

VHA trains rich heads and serves a plain two-head GQA model
The mixes are linear, so they disappear into the projections at inference.
flowchart LR
  X["Hidden state<br/><small>token input</small>"] --> Q["Q proj + Premix<br/><small>folded, half heads</small>"]
  X --> K["K,V proj<br/><small>only 2 KV heads</small>"]
  Q --> A["GQA-2 attention<br/><small>group size up to 64</small>"]
  K --> A
  A --> O["O proj + Postmix<br/><small>folded low-rank mix</small>"]
  K --> C["KV cache<br/><small>2-4x smaller</small>"]
  classDef input fill:#d0ebff,stroke:#1971c2,color:#1b1b1b,stroke-width:2px
  classDef core fill:#e5dbff,stroke:#6741d9,color:#1b1b1b,stroke-width:2px
  classDef exit fill:#d3f9d8,stroke:#2f9e44,color:#1b1b1b,stroke-width:2px
  class X input
  class Q,K,A,O core
  class C exit
Blue is input, purple the attention block as served, green the cache saving.

What is it about? Two papers that shrink the KV cache from different ends. Virtual Head Attention (VHA) changes the architecture so fewer KV heads are needed. PN-Mix changes the numbers, storing keys at about 2 bits.

What problem does it solve? Attention design faces three costs that pull against each other: cache size, training and prefill compute, and quality. GQA (grouped-query attention, where several query heads share one KV head) keeps quality but has a large cache. MLA compresses the cache but loses some quality and needs its own kernels. On the numeric side, 2-bit key caches usually wreck accuracy, and existing mixed-precision methods pick which channels to protect using key statistics only.

What's the core novelty? VHA halves the physical query heads. It then recovers "virtual" head diversity with two linear steps: a near-identity Premix on queries inside each KV group, and a low-rank Postmix across heads after attention. Both are linear, so at inference they merge into the existing query and output projections. The served model is a standard GQA model with two KV heads that reuses every existing GQA kernel. PN-Mix finds that key-quantization error matters most in RoPE channel pairs (RoPE is the rotary position encoding applied to keys) where the product of query and key norms is large. It picks those pairs once at prefill and gives them more bits.

Key takeaways

Gaps in the study VHA's scaling runs use only 4K-8K context. The long-context claim rests on one matched pair. PN-Mix picks salient pairs at prefill and keeps them fixed. It does not show that choice still holds after 30K or more generated tokens.

Industrial implication If VHA holds up, it removes the main reason to adopt MLA: you get a smaller cache with no new kernels. Labs designing their next MoE should run this ablation. Fewer KV heads also means larger groups per head (up to 64), which fills tensor cores better during decode.

Research angle PN-Mix brings the wiki's "find the fragile slice and protect only that" pattern to n=4 in five days. QuantMLA (10-13) protected the RoPE path of MLA's cache. ReplaySSM (10-13) protected the state writes in hybrids. KV4-RL (10-16) kept attention sinks and recent tokens at 8 bits. PN-Mix now protects the high-norm RoPE pairs. Two of the four point to RoPE as where errors grow. An open test is to combine VHA's two heads with PN-Mix's pair selection. Fewer heads may mean each pair carries more, which could make the choice more fragile.

→ Full summary

FlashMask-3: the mask decides what gets sent

In long-context training, the attention mask is the bottleneck. FlashMask-3 uses it to skip both compute and communication.

Source: HuggingFace Daily Papers Links: Paper · Wiki summary

The mask is cut locally and decides what gets sent
No rank asks another for its piece of the mask.
flowchart LR
  M["Global mask<br/><small>4 boundary vectors</small>"] --> L["Local clip-shift<br/><small>zero communication</small>"]
  L --> B["Load balancer<br/><small>sparsity-aware</small>"]
  B --> K["Hopper kernel<br/><small>TMA, WGMMA, 3 roles</small>"]
  L --> P["Comm pruning<br/><small>skip masked KV</small>"]
  P --> K
  K --> T["Throughput<br/><small>1.8-3.7x vs ring CP</small>"]
  classDef input fill:#d0ebff,stroke:#1971c2,color:#1b1b1b,stroke-width:2px
  classDef core fill:#e5dbff,stroke:#6741d9,color:#1b1b1b,stroke-width:2px
  classDef loop fill:#fff3bf,stroke:#f08c00,color:#1b1b1b,stroke-width:2px
  classDef exit fill:#d3f9d8,stroke:#2f9e44,color:#1b1b1b,stroke-width:2px
  class M input
  class L,B,P loop
  class K core
  class T exit
Blue is the mask, amber the per-rank decisions, purple the kernel, green the result.

What is it about? A GPU attention kernel for long-context training that handles structured masks (document boundaries, prefix-LM, sliding windows, block-sparse) across many GPUs at once.

What problem does it solve? FlashMask stored a mask in O(n) memory as four boundary vectors per query axis, but it ran only on Ampere GPUs and a single device. It could not use Hopper's FlashAttention-3 pipeline and did not support context parallelism (splitting one sequence across GPUs).

What's the core novelty? A Hopper kernel built on FlashAttention-3's async copy engine (TMA) and tensor-core instructions (WGMMA), with warps split into three roles. Each rank cuts out its own slice of the mask with a cheap clip-shift-max on the boundary vectors, so no mask data moves between GPUs. A load balancer spreads the uneven sparsity. Then the overlap scheduler skips sending KV blocks the mask makes irrelevant.

Key takeaways

Gaps in the study Hopper only, with no Blackwell port. The end-to-end gain is far smaller than the kernel gain, because attention is only part of a MoE step.

Industrial implication Any lab training long-context models with packed documents (most of them) loses time to mask overhead today. This is a drop-in candidate for Megatron-style stacks.

Research angle This is the training-side version of a pattern from the last two days. DoSA (10-15) skipped scoring keys that could not make the top-K. JSSA (10-16) read only the tokens that matter at decode. FlashMask-3 skips sending what the mask rules out. Sparsity is now exploited at the network layer. The open question is whether the same pruning applies to inference context parallelism, which the remote-KV paper above runs at PCP8.

→ Full summary

NVIDIA Dory1.0-4B and Tencent DSpine: looped models and drafters ship

One 4B checkpoint runs 1, 2 or 4 loops. Its cache stays the size of one pass, and it was pre-trained in 4-bit.

Source: AI lab releases (Hugging Face model cards) Links: Dory card · DSpine card · DSpine paper · Wiki summary

One set of weights, three compute budgets
Only the middle block repeats, and only its last pass is cached.
flowchart LR
  I["Input block<br/><small>8 layers</small>"] --> R["Recurrent block<br/><small>20 shared layers</small>"]
  R -->|loop 1-4x| R
  R --> O["Output block<br/><small>8 layers</small>"]
  R --> K["Last-loop KV<br/><small>one cache per layer</small>"]
  O --> Y["Next token<br/><small>fewer tokens per task</small>"]
  classDef input fill:#d0ebff,stroke:#1971c2,color:#1b1b1b,stroke-width:2px
  classDef core fill:#e5dbff,stroke:#6741d9,color:#1b1b1b,stroke-width:2px
  classDef loop fill:#fff3bf,stroke:#f08c00,color:#1b1b1b,stroke-width:2px
  classDef exit fill:#d3f9d8,stroke:#2f9e44,color:#1b1b1b,stroke-width:2px
  class I input
  class R loop
  class O core
  class K,Y exit
  linkStyle 1 stroke:#f08c00,stroke-width:2px
Blue is input, amber the loop, purple the output block, green what you save.

What is it about? Two open releases that turn recent efficiency research into checkpoints you can download. Dory is a looped model: it runs the same block of layers several times per token to think harder without writing more tokens. DSpine is a draft model for speculative decoding.

What problem does it solve? Looped models normally store a separate KV cache for every loop, so memory grows with each extra loop. Parallel drafters (which guess several tokens at once) lose accuracy because each guessed position cannot see the one before it.

What's the core novelty? Dory has 8 input layers, a 20-layer shared block that repeats, and 8 output layers. It feeds the input back in on each loop. One checkpoint serves different compute budgets by changing the loop count, with no retraining. It caches only the last loop's KV, so it has no cache overhead versus a normal model at any loop count. It was pre-trained natively in NVFP4 (NVIDIA's 4-bit float), then continued in BF16. DSpine drafts all positions in parallel but, at every draft layer, passes each position its predecessor's predicted feature. The left-to-right chain is built up through depth instead of through time.

Key takeaways

Gaps in the study Dory reports no latency per loop count. Loops add no cache but still cost compute. DSpine reports acceptance length, not wall-clock speedup under batching.

Industrial implication A small model whose quality can be dialed up per request without a model swap is a natural fit for routers. You route to "more loops" instead of "bigger model," with no cache penalty. Expect serving engines to expose loop count as a request parameter.

Research angle The path from research to product took days. ELR (10-13) proposed caching only the last loop. ResidualQuant (10-14) showed per-loop caches are nearly redundant. LatentLoop (covered 10-16) scaled looped MoEs. Dory ships the idea. Elorian's Glimpse (below) applies the same latent-recurrence idea to images. The 10-16 warning about drafters still stands: acceptance on long agent traces is the number that matters, and DSpine does not report it.

→ Full summary

Waypoint-OPD: distill only the RL lessons that stayed consistent

One extra teacher checkpoint shows which preferences RL built steadily and which it flip-flopped on. Distill only the steady ones.

Source: HuggingFace Daily Papers (top paper, 660 upvotes) Links: Paper · Wiki summary

Keep the shift only where early and late RL agree
One extra checkpoint turns a single difference into a direction check.
flowchart LR
  S["Student rollout<br/><small>on-policy prefixes</small>"] --> B["Base teacher<br/><small>before RL</small>"]
  S --> W["Waypoint teacher<br/><small>mid RL run</small>"]
  S --> E["Final teacher<br/><small>after RL</small>"]
  B --> G{"Agreement gate<br/><small>early vs late shift</small>"}
  W --> G
  E --> G
  G -->|agree| U["Student update<br/><small>shift kept</small>"]
  G -->|oppose| Z["Suppressed<br/><small>shift zeroed</small>"]
  classDef input fill:#d0ebff,stroke:#1971c2,color:#1b1b1b,stroke-width:2px
  classDef core fill:#e5dbff,stroke:#6741d9,color:#1b1b1b,stroke-width:2px
  classDef loop fill:#fff3bf,stroke:#f08c00,color:#1b1b1b,stroke-width:2px
  classDef exit fill:#d3f9d8,stroke:#2f9e44,color:#1b1b1b,stroke-width:2px
  classDef err fill:#ffe3e3,stroke:#e03131,color:#1b1b1b,stroke-width:2px
  class S input
  class B,W,E core
  class G loop
  class U exit
  class Z err
Blue is the student's own text, purple the three frozen teachers, amber the gate, green kept signal, red dropped signal.

What is it about? A distillation method that transfers what RL taught a teacher model into a student. It uses on-policy distillation (the student generates text and the teacher scores it).

What problem does it solve? Policy-shift distillation supervises the student with the teacher's log-probability change from before RL to after RL. That endpoint difference hides history. A preference that rose early and fell late looks the same as one that rose steadily.

What's the core novelty? Add one intermediate checkpoint from the same RL run. At each prefix the student visits, compare the early shift (start to midpoint) with the late shift (midpoint to end). Where they point in opposite directions, switch the endpoint signal off. The only added cost is one more frozen-teacher scoring pass.

Key takeaways

Gaps in the study Only one waypoint, with no sweep over where it sits. All teachers are 4B.

Industrial implication Labs that already keep RL checkpoints get this almost free. It fits the post-RL distillation step most open-weight releases now run.

Research angle This is the fifth on-policy-distillation fix in two days. The 10-16 digest covered four, including Road MOPD (using non-routed teachers as critics) and CriticOPD (restoring teacher "recoverability" on wrong prefixes). Waypoint-OPD is the first to read the teacher's training trajectory rather than its final weights. Also today, Tencent's Hy-Memory-30B-A3B trains a memory-writing model with memory OPD followed by RL. It beats Claude Opus 5 as the writer inside Mem0 and MemOS (55.49 vs 54.62 on average).

→ Full summary

Agents that improve agents: Athanor, Terminal-RSI and a 27-hour Minecraft run

Four Opus 5.5 agents, given GPUs and no advice, post-trained a raw 4B base past its official instruct model. They used known methods.

Source: HuggingFace Daily Papers; Minecraft and Terminal-RSI also on X Links: Athanor · Terminal-RSI · Harness RSI · Minecraft · AutoSFT · Wiki summary

The loop is the product, and the model is one box in it
Every paper here keeps the evaluator out of the agent's reach.
flowchart LR
  T["Task + budget<br/><small>GPUs, sandbox</small>"] --> A["Agent team<br/><small>frontier models</small>"]
  A --> X["Experiment<br/><small>train, run, play</small>"]
  X --> V["Frozen evaluator<br/><small>held-out suite</small>"]
  V --> M{"Admit change?<br/><small>validation gate</small>"}
  M -->|yes| R["Research record<br/><small>persistent memory</small>"]
  R --> A
  M -->|no| D["Discard<br/><small>regression budget</small>"]
  classDef input fill:#d0ebff,stroke:#1971c2,color:#1b1b1b,stroke-width:2px
  classDef core fill:#e5dbff,stroke:#6741d9,color:#1b1b1b,stroke-width:2px
  classDef loop fill:#fff3bf,stroke:#f08c00,color:#1b1b1b,stroke-width:2px
  classDef exit fill:#d3f9d8,stroke:#2f9e44,color:#1b1b1b,stroke-width:2px
  classDef err fill:#ffe3e3,stroke:#e03131,color:#1b1b1b,stroke-width:2px
  class T input
  class A,X core
  class V,M loop
  class R exit
  class D err
  linkStyle 5 stroke:#f08c00,stroke-width:2px
Blue is the setup, purple the agents and experiments, amber the evaluation gate, green kept knowledge, red rejected changes.

What is it about? A cluster of papers that measure recursive self-improvement in a form you can check today. In each, agents improve models or their own scaffolding while a frozen evaluator keeps score.

What problem does it solve? Claims about AI improving AI were mostly speculative. These runs report numbers against held-out tests the agents cannot see.

What's the core novelty?

Key takeaways

Gaps in the study Athanor is one campaign on one base model, with no run-to-run variance. Its 32 GPUs times 104 hours is not compared with the human recipe's cost. Minecraft is one seed on Easy difficulty. Harness RSI is theory and survey, with no new experiment.

Industrial implication Cheap specialized post-training is what agents already do well. Ken Huang's 10-16 essay cites Datadog matching frontier models on incident triage at 3-8x lower cost with a specialized model. Expect "agent-run post-training" offerings for vertical small models within two quarters.

→ Full summary

Three models, three cost claims: MAI-Base-2, Reflection Beam, Elorian Glimpse

Microsoft's 2.8T base model used about one in five of its GPUs' peak FLOPs. That is the most useful number in its report.

Source: AI Breakfast (Gmail), AWS Machine Learning blog (lab watcher), X following feed Links: MAI-Base-2 report · Beam on AWS · Glimpse · Wiki summary

What is it about? Three model announcements, each mainly a claim about cost.

What problem does it solve? Each addresses a different cost. Microsoft is after training efficiency. Reflection offers open weights for agentic coding at frontier scale. Elorian is after visual reasoning that does not need long text chains.

What's the core novelty?

Key takeaways

Gaps in the study MAI-Base-2 gives no evals in text and its efficiency figure is fitted. Beam has no independent long-context eval yet. Glimpse's "17x cheaper" compares list prices, not cost per solved task.

Industrial implication Active-parameter share keeps falling: Muse Spark Open (10-16) at 5.1%, Beam at 4.6%, MAI-Base-2 at 2.9%. More memory per useful FLOP is why every release now ships NVFP4 on day one, and why memory pricing matters (see Industry Pulse).

→ Full summary

Claude designs quantum circuits and explains the NIST curve seeds

Given a one-paragraph spec and an automated checker, Claude beat the best published quantum circuits on 7 of 8 tasks.

Source: Anthropic Research (lab watcher); Quantum Zeitgeist (Gmail); DAIR.AI via X Links: Paper · Anthropic post · ECDSA post · Wiki summary

The evaluator, not the model, makes the result trustworthy
Every reported gain is a circuit the checker verified.
flowchart LR
  S["Plain-language spec<br/><small>one paragraph</small>"] --> P["Claude proposes<br/><small>circuit as Python</small>"]
  P --> E["Evaluator<br/><small>basis-state check</small>"]
  E --> C{"TQ-cost<br/><small>Toffoli x qubits</small>"}
  C -->|best| F["Families<br/><small>up to 5 lineages</small>"]
  F --> P
  C -->|final| O["Verified circuit<br/><small>beats published</small>"]
  classDef input fill:#d0ebff,stroke:#1971c2,color:#1b1b1b,stroke-width:2px
  classDef core fill:#e5dbff,stroke:#6741d9,color:#1b1b1b,stroke-width:2px
  classDef loop fill:#fff3bf,stroke:#f08c00,color:#1b1b1b,stroke-width:2px
  classDef exit fill:#d3f9d8,stroke:#2f9e44,color:#1b1b1b,stroke-width:2px
  class S input
  class P core
  class E,C,F loop
  class O exit
  linkStyle 4 stroke:#f08c00,stroke-width:2px
Blue is the spec, purple the model, amber the search-and-check loop, green the verified output.

What is it about? Two Anthropic research posts where a frontier model, given a checker, found results humans had not.

What problem does it solve? Useful quantum algorithms depend on a few costly building blocks. Optimizing them is hard because quantum circuits must be reversible. Separately, the origin of the NSA-supplied seeds behind NIST's elliptic curves had been unexplained for 25 years.

What's the core novelty? Claude Mythos 5 writes circuit-generating Python inside an evolutionary loop (OpenEvolve). The evaluator checks correctness on basis states. That is cheap because these circuits never create superpositions. It then scores Toffoli gates and peak qubits. A trick the search kept finding was to replace conditional arithmetic with conditional routing, so an expensive kernel appears once. That halves the schoolbook Toffoli count. For ECDSA, Claude noticed the seeds' top bits were always zero, which is the signature of C's lrand48 random generator. It then recovered the generator states with a lattice attack (LLL).

Key takeaways

Gaps in the study The circuit search mostly recombined known algorithm families. One ECDSA seed (B-163) and four base points remain unexplained.

Industrial implication Mechanical evaluators turn frontier models into search engines for designs. Fewer qubits per algorithm brings useful quantum hardware closer in time, the same way quantization makes a GPU go further.

→ Full summary

Industry Pulse

Funding, valuations, and compute deals

Global View

The cost of an agent run is moving from the model to the system around it, and research and buyers price it differently. Today's step-level routers cut cost 19-62% by changing who handles each step, HarnessRouter found the harness alone moves cost up to 2.1x, and Harvey's context graph halved task cost on the same model. That extends Arena's Max router (10-14, one model per session at 37% lower cost) and Whose Turn (10-16, where switching up mid-session never repaid the lost prompt cache). Buyers budget per person instead, with Cognition rationing Devin by each engineer's output per dollar (10-16) and Accenture capping Claude at $29 per employee a month, yet no published router optimizes that per-seat budget.

Faster GPUs change what is worth caching, while a memory shortage makes every compressed byte worth more. On B300s a remote KV hit loses to recompute below 17K tokens, reversing the H100-era galahad-kv result (10-09) that NVMe reload was 2.8-4.3x faster than recompute. VHA and PN-Mix keep cutting cache bytes, the fourth and fifth "protect only the fragile slice" results in five days after QuantMLA (RoPE path), ReplaySSM (state writes) and KV4-RL (sinks and recent tokens). Industry says memory is the binding input: HBM is projected at about 30% of DRAM wafers next year, Musk expects a worse 2027, and Nscale's Norway build is six months late, so caching gets harder to justify while compression gets more valuable.

Self-improving agents now ship with frozen evaluators, and deployers answer the same risk with walls. Athanor, the quantum-circuit search and today's verifier-hardening paper (an automated hacker-fixer loop for exploitable agent-environment checks) all keep the scorer out of the agent's reach, following GRAFT (10-16), which confined reward hacking to a deletable adapter. Meanwhile Citi, BofA and JPMorgan block outside agents, CERT-In confirmed test agents reached live Indian systems, and Perplexity open-sourced a sandbox nine frontier models failed to escape. Rachel Thomas's position paper adds that the human overseer is the weak link, and neither better scorekeepers nor higher walls has yet been shown to make that job manageable.

Looking Ahead