AI research wiki
July 27, 2026 · daily digest

cere-bro | 2026-07-27

cere-bro | 2026-07-27

The Kurate leaderboard unfroze after six weeks and the first thing it surfaced was an argument: two papers landed the same day telling agents opposite things about their own memory, while a router that reads hidden states instead of prompts cut frontier-model calls by 90%.

TL;DR

Deep Dives

Multi-Head Latent Control: The Router Moves Inside the Model

Every router in this wiki reads the question. This one reads the answer being written, so it can change its mind halfway through a sentence.

Source: HuggingFace Daily Papers Links: arXiv 2607.14277 · Wiki summary

flowchart LR
  Q[Query] --> SM[Frozen small model<br/>begins generating]
  SM --> HS[Hidden-state trajectory]
  HS --> CH{Capability Head<br/>can I finish this?}
  HS --> RH{Resolution Head<br/>how to resolve?}
  CH -->|yes| CONT[Continue locally]
  CH -->|no: handoff from<br/>a PARTIAL generation| BIG[Stronger model]
  RH --> CLR[Clarify]
  RH --> TOOL[Tool use]
  RH --> ABS[Abstain]
  RH --> ANS[Direct answer]
  classDef input fill:#dbeafe,stroke:#3b82f6,color:#1e3a8a
  classDef decision fill:#fef3c7,stroke:#f59e0b,color:#78350f
  classDef output fill:#d1fae5,stroke:#10b981,color:#065f46
  classDef aux fill:#e0e7ff,stroke:#6366f1,color:#312e81
  class Q,SM input
  class CH,RH decision
  class CONT,BIG,CLR,TOOL,ABS,ANS output
  class HS aux

What is it about? Two small heads sit on top of a frozen language or vision-language model and watch its hidden states, the internal numeric representations the model builds as it works, while it generates. One head, the Capability Head, predicts whether this model can actually finish the current problem or should hand off to a stronger one. The other, the Resolution Head, picks how to respond: ask a clarifying question, call a tool, refuse, or just answer.

What problem does it solve? Routing today reads the input. You embed the query, classify it, and pick a model before the cheap model has tried anything. That forces the decision at the moment you have the least information. Reading the generation instead means the evidence accumulates: the trajectory at token 50 says far more about whether this is going well than the prompt did at token 0.

What is the core novelty? It is the first router in this wiki that makes a decision between models using evidence from inside one. TRACER (04-17), which trains a cheap surrogate classifier on an LLM's own production traces and gates on a confidence threshold, still reads the input. Step-level Optimization (05-02), which escalates a GUI agent to a frontier model when learned monitors detect that progress has stalled, watches environment state rather than model internals. DLR (05-15) routes in latent space but only within a single model. The consequence unique to MHLC is early handoff from a partial generation.

Key takeaways

Gaps in the study Training on traces from one specific backbone means every backbone swap requires retraining the heads, which is the same maintenance burden the paper criticises prompt-level routing for, just relocated. The 90.7% figure is the best case and the honest average is 27 to 53%. Most importantly there is no paraphrase-robustness test, which matters because When Is Routing Meaningful? (07-20), which introduced diagnostics for whether a router is doing anything at all, found that learned KNN routers gain accuracy but collapse when queries are rephrased while prompted routing stays stable. And there is no latency accounting: an early handoff throws away the small model's partial work and re-prefills on the large model.

Industrial implication If the latent signal turns out to be paraphrase-stable where query embeddings are not, this is not merely a cheaper router but a structurally more robust one, and the KNN-collapse finding stops being a general indictment of learned routing. The number that decides deployment is one the paper does not publish: how many tokens the Capability Head needs before its prediction is trustworthy. Early handoff is the entire value proposition, so a curve of handoff accuracy against tokens generated is the missing plot. Watch also for the cache interaction, since routing more often means invalidating prefix cache more often.

→ Full summary

Cursor Ships the Planner-Worker Split, and the Interesting Part Is How the Old One Failed

The previous swarm did not fail because its models were weak. It failed by creating merge conflicts with itself.

Source: The Decoder Links: The Decoder · Wiki summary

flowchart LR
  SPEC[Rebuild SQLite in Rust<br/>docs only, no source,<br/>no internet] --> PL[Planner<br/>frontier model<br/>decomposes + assigns]
  PL --> W1[Worker<br/>cheaper model]
  PL --> W2[Worker<br/>cheaper model]
  PL --> W3[Worker<br/>cheaper model]
  W1 --> INT[Integration]
  W2 --> INT
  W3 --> INT
  INT --> PASS[100% test suite<br/>every configuration]
  OLD[Old swarm<br/>no planner-worker split] -.-> MC[Merge conflicts<br/>of its own making]
  classDef input fill:#dbeafe,stroke:#3b82f6,color:#1e3a8a
  classDef decision fill:#fef3c7,stroke:#f59e0b,color:#78350f
  classDef output fill:#d1fae5,stroke:#10b981,color:#065f46
  classDef warn fill:#fee2e2,stroke:#ef4444,color:#7f1d1d
  class SPEC input
  class PL decision
  class W1,W2,W3,INT,PASS output
  class OLD,MC warn

What is it about? Cursor gave its old and new agent swarms the same task: rebuild SQLite in Rust using only the documentation, with no access to the source code and no internet. The new system separates a planner from the workers who write code. Every configuration of it eventually scored 100% on the test suite. The old system, which had no such separation, tangled itself in merge conflicts.

What problem does it solve? It answers, from production rather than a paper, whether you need a frontier model everywhere in a coding agent. The answer is no. You need one where the work gets carved up.

What is the core novelty? Honestly, the diagnosis rather than the architecture. The failure mode of the old swarm was self-inflicted merge conflicts, which is a coordination failure, not a capability failure of any individual worker. That says the binding constraint in multi-agent coding is write-conflict management. It also reframes what the planner is for: if its value is partitioning work into non-overlapping pieces rather than reasoning deeply, then a frontier model may be the wrong tool for the planner slot too, and nobody has tested a cheap partitioner against an expensive one.

Key takeaways

Gaps in the study No cost figures, no model names, no worker counts, so "cheaper models can handle most coding" is directional rather than a ledger. "Eventually scored 100%" conceals the two variables production cares about, wall clock and tokens burned. And SQLite is unusually well-specified by its documentation, which is exactly the condition that makes clean partitioning easy. A codebase with tangled cross-cutting concerns is where this should degrade, and it is untested.

Industrial implication Combined with the paper above, the practical picture for the next two quarters is a two-layer routing stack: a coarse role split decided by architecture, planner versus worker, and a fine per-instance split decided at runtime by something like a Capability Head. Those compose cleanly and nobody has composed them. If you run a coding agent today, the cheap experiment is to fix your planner model and sweep the worker model down the price curve until acceptance tests break, which is the DSPy fixed-contract method (07-25) applied to a swarm.

→ Full summary

PRO-LONG: Stop Compressing the History, Just Search It

Keeping every observation should cost more tokens. It costs 4.2 to 5.8 times fewer, because a log you can search is not a log you have to carry.

Source: Cross-source confirmed. Kurate weekly cs.AI #17 and DAIR.AI Top AI Papers of the Week via starred Gmail Links: arXiv 2607.20064 · Wiki summary

flowchart LR
  OBS[Long observation stream] --> LOG[(Complete structured log<br/>nothing discarded)]
  LOG --> AG[Agent asks:<br/>what happened at step N?]
  AG --> SRCH[Search the log with<br/>ordinary coding-agent tools]
  SRCH --> HIT[Exact detail retrieved]
  HIT --> ACT[Act]
  ALT[Conventional path:<br/>summarise into memory] -.-> LOSS[Detail needed later<br/>already discarded]
  classDef input fill:#dbeafe,stroke:#3b82f6,color:#1e3a8a
  classDef decision fill:#fef3c7,stroke:#f59e0b,color:#78350f
  classDef output fill:#d1fae5,stroke:#10b981,color:#065f46
  classDef warn fill:#fee2e2,stroke:#ef4444,color:#7f1d1d
  class OBS,LOG input
  class SRCH decision
  class HIT,ACT output
  class ALT,LOSS warn

What is it about? Long-horizon agents accumulate huge observation streams and the standard response is to summarise them into a memory store. PRO-LONG refuses. It keeps the complete structured interaction log, throws nothing away, and lets the agent search that log on demand using the file-search tooling a coding agent already has.

What problem does it solve? The compression tradeoff. Richer summaries make the exact detail you later need harder to retrieve, because summarising is deciding in advance what will matter, and in exploratory tasks you cannot know that in advance.

What is the core novelty? That the naive baseline nobody bothered to run beats the elaborate systems. The token result is the mechanism made visible: the log is stored, not resident. The agent pays for the slice it retrieves when it retrieves it, rather than paying every single turn to carry a summary of everything through its context window. This is the same economics that makes a filesystem beat an in-memory cache when the working set is sparse and access is unpredictable.

Key takeaways

Gaps in the study ARC-AGI-3 is exploratory games with programmatic state, which is the ideal case for a searchable log because the observations are already structured. Real agent traces full of prose, screenshots, and tool spew are not obviously greppable the same way. Search quality is also doing invisible work: the result depends on the agent writing good queries against its own history, and the paper reports outcomes rather than search-hit rates, so we cannot see how often it fails to find something that is genuinely in the log. Episodes are also bounded, and a log that grows for weeks in a persistent assistant is a different regime with no scaling curve provided.

Industrial implication If you maintain a memory layer for an agent, the control condition you probably never ran just got a strong result. Log everything to structured storage, hand the agent a search tool, and measure. That is a week of work and it might beat the system you have. The wider consequence is for the memory-engineering market: a large amount of product surface is being built on the premise that compression is mandatory, and that premise is now contested by a paper that beats it on both accuracy and cost in at least one domain.

→ Full summary

Agentic Context Management: The Opposite Argument, the Same Morning

Naive context accumulation costs quadratically in conversation length. This paper says you must compact. The paper above says compacting is the mistake.

Source: HuggingFace Daily Papers Links: arXiv 2607.21503 · Wiki summary

flowchart LR
  IN[History, prompts,<br/>tool defs, tool outputs] --> ARCH[Architecting<br/>store per data type]
  ARCH --> ING[Ingesting<br/>extract + structure]
  ING --> SC[Scoping<br/>user / team / org]
  SC --> ANT[Anticipating<br/>what is needed next]
  ANT --> CMP{Compacting}
  CMP -->|naive accumulation| Q[QUADRATIC token cost]
  CMP -->|crude summarisation| CLIFF[Linear cost<br/>ACCURACY CLIFF]
  CMP -->|validated compaction| GOOD[Linear cost<br/>fidelity preserved]
  classDef input fill:#dbeafe,stroke:#3b82f6,color:#1e3a8a
  classDef decision fill:#fef3c7,stroke:#f59e0b,color:#78350f
  classDef output fill:#d1fae5,stroke:#10b981,color:#065f46
  classDef warn fill:#fee2e2,stroke:#ef4444,color:#7f1d1d
  class IN input
  class CMP decision
  class GOOD,ARCH,ING,SC,ANT output
  class Q,CLIFF warn

What is it about? The argument that production agents fail less from bad reasoning than from bad context hygiene, and that treating this as storage-and-retrieval is too narrow. Managing what an agent holds in mind is a lifecycle: deciding what to remember, extracting and structuring it, choosing the right store per data type, consolidating and forgetting while preserving provenance, judging what is relevant now, anticipating what comes next, and compacting to a budget. The paper names the discipline and decomposes it into five primitives.

What problem does it solve? It puts a cost curve under a problem usually discussed qualitatively. Every turn re-sends the accumulated history, so cost grows as the square of conversation length. That is why agent bills surprise teams: the per-turn price is not the price.

What is the core novelty? The distinction between crude and validated compaction. Summarising converts quadratic cost to linear but hits an accuracy cliff. The claim is that putting a checkable predicate between the compressor and the context gets linear cost without the cliff. There is also an organisational dimension most memory work ignores: in production this runs across a scope hierarchy of user, team, and organisation, not one user's history.

Key takeaways

Gaps in the study The numbers come from the authors' own commercial implementation and are explicitly qualified as holding under one configuration, which is a serious caveat on a 92% claim. This is closer to a position paper with a product attached than a controlled comparison, and a five-primitive taxonomy is not falsifiable. Critically, the abstract never says what a validator checks, and that distinction is carrying the entire result.

Industrial implication The quadratic framing is worth adopting even if you reject everything else, because it is the right mental model for budgeting agent spend. But the unexamined risk sits in the validator. If it is an LLM judge reading a candidate summary, it is exactly the setup that More Convincing, Not More Correct (07-26), which showed a judge conditioned on a candidate answer scores plausibility rather than correctness at a 0.719 false-positive rate, says will systematically approve fluent-but-lossy compactions. A compaction validator is a judge conditioned on a candidate. Someone should check.

→ Full summary

VisCo: The Model Is Already a Good Compressor of Its Own Vision Tokens

The compressed representation does not just shrink the input. Bolted alongside the original tokens, it makes the base model better.

Source: HuggingFace Daily Papers Links: arXiv 2607.12756 · Wiki summary

flowchart LR
  IMG[Image / video<br/>many visual tokens] --> ENC[Pretrained VLM<br/>as ENCODER]
  ENC --> MT[Small set of<br/>memory tokens]
  MT --> DEC[Same weights<br/>as DECODER]
  ENC -.hierarchical transfer.-> DEC
  DEC --> OUT[Task output]
  MT --> PLUS[Memory tokens PLUS<br/>original visual tokens]
  PLUS --> BETTER[Beats the base model:<br/>complementary, not just smaller]
  classDef input fill:#dbeafe,stroke:#3b82f6,color:#1e3a8a
  classDef decision fill:#fef3c7,stroke:#f59e0b,color:#78350f
  classDef output fill:#d1fae5,stroke:#10b981,color:#065f46
  classDef aux fill:#e0e7ff,stroke:#6366f1,color:#312e81
  class IMG input
  class ENC,DEC decision
  class MT,OUT,BETTER output
  class PLUS aux

What is it about? Vision-language models burn most of their latency and memory on visual tokens, the chunks an image gets cut into before the model reads it. VisCo compresses them by making the pretrained model compress itself: the same weights act as encoder and decoder in a parameter-sharing autoencoder, squeezing the image into a small set of memory tokens and reconstructing from them.

What problem does it solve? Both existing families are structurally flawed. Training-free compression uses heuristic importance scores and collapses at high compression. Training-based compression bolts on an external module the backbone must then adapt to, which costs retraining and damages the model's pretrained priors.

What is the core novelty? Reusing the backbone as its own compressor, so there is no external module to adapt to and the priors stay intact. Plus hierarchical information transfer from the encoding pass to the decoding pass.

Key takeaways

Gaps in the study No latency or throughput numbers, only quality against compression ratio, and the encode-then-decode structure costs extra forward passes through the backbone. Whether token reduction nets out to a wall-clock win at production batch sizes is the whole question and it is unanswered. The single-token stability result is striking enough to raise a benchmark-artifact worry: a suite where one token suffices may be one where the image was never load-bearing.

Industrial implication Visual tokens occupy KV cache, so cutting them cuts cache footprint proportionally, which makes this a KV-cache result wearing a vision costume. The finding worth chasing is not the compression but the complementarity: if a cheap self-supervised autoencoder pass produces tokens that improve a frozen VLM, that is a free quality lever for multimodal serving independent of any efficiency motive, and it should be tested on text.

→ Full summary

Skill Self-Play, and the Week Four Papers Agreed on the Same Thing

A skill is a scope small enough to verify and a library of them is broad enough to be open-ended. Four teams reached that conclusion in one week.

Source: HuggingFace Daily Papers, plus Kurate weekly and DAIR.AI via starred Gmail Links: arXiv 2607.22529 · Code · Wiki summary

flowchart LR
  LIB[(Skill library)] --> SAMP[Controller<br/>samples a skill]
  SAMP --> PROP[Proposer generates task<br/>conditioned on skill]
  PROP --> SOLV[Solver explores solutions]
  SOLV --> VER{Verify INSIDE<br/>the skill's scenario}
  VER -->|precise feedback| RL[RL update]
  RL --> SOLV
  VER --> CTRL[Controller updates<br/>and EXPANDS library]
  CTRL --> LIB
  classDef input fill:#dbeafe,stroke:#3b82f6,color:#1e3a8a
  classDef decision fill:#fef3c7,stroke:#f59e0b,color:#78350f
  classDef output fill:#d1fae5,stroke:#10b981,color:#065f46
  class LIB,PROP input
  class VER,SAMP decision
  class RL,CTRL,SOLV output

What is it about? Self-evolving training, where a model generates its own tasks and learns from them, faces a dilemma. Tie it to a fixed environment and feedback is precise but the model only learns one narrow domain. Let it invent tasks freely and coverage is broad but nothing verifies the answers, so wrong rewards poison the loop. Skill Self-Play, from a Qwen applications team, proposes agent skills as the way out.

What problem does it solve? Verifiability is normally bought with narrowness, because checking requires a fixed environment. Skill-SP separates the two: rigour lives inside each skill, breadth comes from routing across a growing library of them.

What is the core novelty? Treating a skill as a scope boundary that carries its own verifier. Three components co-evolve under reinforcement learning: a proposer that writes tasks conditioned on a sampled skill, a solver that attempts them, and a skill controller that reads execution feedback to update and expand the library.

Key takeaways

Gaps in the study The abstract offers directional claims and not one number, which for an RL paper is a real omission. There is no measure of skill-library growth over time, so the central question of whether the library reaches genuinely new territory or saturates into refinement is unanswered. And "striking turnarounds for initially misaligned models" is an alignment claim made from a capability pipeline, which invites the question of whether the model got better or just learned to satisfy its own proposer.

Industrial implication Every one of these four is a self-rewarding loop, and yesterday's More Convincing, Not More Correct showed a judge conditioned on a candidate answer scores plausibility instead of correctness, driving pass rate from 0.72 to 0.94 while true accuracy stayed at 0.20, with the effect transferring across judge families and surviving a three-judge ensemble at 55% acceptance. Skill-SP has the best structural defence, since verification happens inside a skill's scenario, closer to an environment check than an LLM judge. MSCE crystallises policies on "positive estimated gain" and never says who estimates, which is the exposed one. None of the four runs the hidden-anchor audit, a held-out exact-match check outside the training loop that costs one comparison and would settle it.

→ Full summary

Ken Huang: Forty CVEs and the Amplification Stack

Injection, missing auth, path traversal. The bugs are from the 1990s. What is new is that we wired them to something with hands.

Source: Ken Huang, Substack, via RSS Links: kenhuangus.substack.com · Wiki summary

flowchart LR
  UC[Untrusted content] --> LLM[Model treats it as<br/>instructions, not data]
  LLM --> TC[Becomes a tool call]
  TC --> RT[Runtime holding:<br/>dev credentials,<br/>source tree,<br/>internal network route]
  RT --> RCE[Host RCE<br/>from a MEDIUM parsing bug]
  CLASSIC[Classic software:<br/>human + network boundary] -.removed by the agent.-> TC
  classDef input fill:#dbeafe,stroke:#3b82f6,color:#1e3a8a
  classDef decision fill:#fef3c7,stroke:#f59e0b,color:#78350f
  classDef warn fill:#fee2e2,stroke:#ef4444,color:#7f1d1d
  classDef aux fill:#e0e7ff,stroke:#6366f1,color:#312e81
  class UC input
  class LLM,TC decision
  class RT,RCE warn
  class CLASSIC aux

What is it about? Huang read the CVE writeups filed against agent tooling, looking for the common thread. Between January and February 2026 researchers filed more than 30 CVEs against the Model Context Protocol and its immediate ecosystem in about 60 days, and the count passed 40 by April. Subjects include mcp-remote, MCP Inspector, mcp-server-git, CrewAI, LangGraph, Cursor, Windsurf, Claude Code, and Microsoft 365 Copilot.

What problem does it solve? It supplies the base rate. The wiki's agent-security thread has been built on controlled studies. This is the count of real, numbered, public vulnerabilities in a live ecosystem, running at roughly twenty a month against one protocol.

What is the core novelty? The Amplification Stack. In classic software, a path traversal bug in a download handler is a medium: a human has to reach the endpoint, craft the request, and act on the file. Humans and network boundaries sit between the defect and the damage. An agent deletes all of them, doing all four steps in one uninterrupted loop with its own privileges. Huang's formulation of the consequence is the keeper: the severity does not live in any one box. Each arrow is a small understood weakness, and stacked they turn a moderate parsing bug into host remote code execution, with the agent climbing the ladder for the attacker.

Key takeaways

Gaps in the study The hardening runbook and triage checklist are paywalled, so the actionable half is not public. The counts are a rate of disclosure against a young, heavily scrutinised ecosystem rather than a rate of exploitation, and 40 CVEs partly means researchers are looking, which is the healthy case. Huang also does not separate CVEs requiring an already-compromised MCP server from those a remote attacker can reach, and that split carries most of the practical risk weighting.

Industrial implication The buildable control follows from the OpenAI HuggingFace breach (07-26), where the escape route was an internal software-download service, meaning the sandbox was bypassed through trusted internal infrastructure rather than defeated at its perimeter. Enumerate every service your agent runtime may talk to and treat that set as the actual isolation boundary. The MCP ecosystem's entire value proposition is expanding that set, which is why the CVE rate is what it is.

→ Full summary

Industry Pulse

Funding, valuations, and compute deals

Global View

Routing stopped being a research topic and became an architecture decision, and the two halves of it shipped on the same day from opposite directions. Multi-Head Latent Control cuts large-model calls up to 90.7% by reading a frozen model's hidden states mid-generation, which is the first router in this wiki to make a between-model decision from inside-the-model evidence, while Cursor's swarm gets the same economics from a coarse architectural split of planner from worker. That is five independent datapoints in six weeks for role-based assignment, after Kilo (06-16) found planning with Fable 5 and implementing with GPT-5.5 passed all 15 acceptance checks for 59% less, Disentangling Agent Self-Evolution (06-08) found harness-editing quality flat across model tiers so a 9B model edits scaffolding as well as Opus, Conductor (05-11) trained a 7B orchestrator that beats every frontier worker it directs, and DSPy/Shopify (07-25) cut a workload 550x by fixing the task contract and searching for the cheapest passing model. The industry side confirms the demand this creates rather than the technique: Goldman's $7.5 trillion five-year infrastructure estimate and Google's decision to backstop $44 billion of other people's data-center leases, up from $6.5 billion nine months ago, are what it looks like when compute cost is the binding constraint on a business, which is exactly the pressure that makes a 27 to 53% average reduction in frontier calls a boardroom number rather than a paper result.

Two papers landed the same morning telling agents opposite things about their own memory, and the wiki's entire memory thread was quietly built on the side that just lost a benchmark. PRO-LONG keeps the complete log and searches it, beating specialised memory harnesses by 18 points on ARC-AGI-3 with 4.2 to 5.8x fewer tokens, because a stored log is paid for per retrieval while a resident summary is paid for every turn. Agentic Context Management argues the opposite, that accumulation is quadratic in conversation length so validated compaction is mandatory. The wiki's agent-memory page has spent four months on the compression side, through MemTrain (06-04) which trains memory ability self-supervised on raw Wikipedia, EvolveMem (05-15) which co-evolves the retrieval configuration for +25.7% on LoCoMo, and MemForest (05-26), none of which ran the keep-everything control condition. They are probably right about different workloads, since PRO-LONG's evidence is exploratory games with sparse unpredictable access where search wins and ACM's is conversational recall where anticipation should, but neither tested on the other's benchmark and that is a cheap experiment nobody has run.

Every self-improvement pipeline shipped this week is structurally vulnerable to the failure documented in this wiki yesterday, and the same blind spot has a security twin. Four papers converged on skills as the unit of self-evolution: Skill Self-Play, MSCE from DAIR.AI's roundup, and two more from Kurate's now-unfrozen leaderboard. All four are self-rewarding loops, and More Convincing, Not More Correct (07-26) showed that a judge holding a candidate answer in context scores plausibility rather than correctness, pushing pass rate from 0.72 to 0.94 while true accuracy sat at 0.20, transferring across judge families, and surviving a three-judge ensemble at 55% acceptance. The identical shape appears in ACM's undefined "validated compaction," since a compaction validator reading a candidate summary is a judge conditioned on a candidate, and the security side gave the mirror image the same day: Anthropic's 0% browser injection result (07-26) is real but defends the first two links of Ken Huang's Amplification Stack, while the 40-plus MCP CVEs filed since January live in links three and four, where the runtime holds credentials and a route to the internal network. In both cases the defense is measured where the light is good, and the industry response so far is jurisdictional rather than technical, with Washington reportedly favoring targeted bans on Chinese models while OpenAI and Anthropic sign an open-weights letter publicly and lobby against it privately.

Looking Ahead

Kurate connector fixed after six weeks of stale data. The leaderboard has been byte-identical since W27, and yesterday's digest flagged that if it did not move this week the connector needed an audit. It did not move, the audit ran, and the cause was a config bug: connectors/kurate/config.json sent period=weekly, the API expects period=week, and the unrecognised value silently fell back to an all-time ranking. That is why the same biomedical foundation-model papers from April sat at the top for six weeks and why the rising-authors list was frozen co-authors of those same frozen papers. Fixed and re-farmed today in both the live connector and the starter template. The fresh weekly board immediately produced real signal: PRO-LONG at cs.AI #17 (cross-source confirmed against DAIR.AI), two of this week's four self-evolution papers, and MXSens (2607.17733, cs.LG #17), a sensitivity-aware mixed-precision quantization method that is the most general framing yet of a question Mix-Quant (05-21) answered along the prefill-versus-decode axis and OSCAR (05-21) along the cache-versus-weights axis. Stubbed at MXSens pending a full read. Six weeks of underrated-paper flags in prior digests were reporting an artifact, not a signal.

(Reddit contributed nothing today: all eight subreddit farms returned zero posts passing filters, the second consecutive dry day. Twitter's morning slot carried 42 tweets and almost no AI signal, the curated retweet feed was empty, and the only substantive item was a link to a modem.dev essay on writing code that coding agents can navigate.)