1. Declarative Attention
A model reads its entire KV cache on every generated token, even though it ends up attending to a tiny slice of it. Ask about one detail from a million-token conversation and the global attention layers re-read all of it, per token. Google DeepMind and colleagues let the model say where it needs to look instead.
The declaration lives in the chain-of-thought: Generation splits into three modes. Global reads the full context, focus reads one specific region, and local reads only recent output. The model emits those tags in its own reasoning, so nothing about the weights changes.
The inference engine treats it like a tool call: It parses the declarations the same way it parses function calls and skips most of the cache read. The usual alternative guesses at relevant tokens with cheap proxy scores, which still costs O(N) at every step.
Zero-shot on off-the-shelf weights: Across 15 long-context tasks, attended tokens during decoding drop 52.0% on Gemma-4-31B and 31.1% on Qwen-3.6-27B, at a 1 to 3 point average accuracy cost.
Why it matters: Long-context serving costs are a structural problem for anyone running agents over large repositories or long conversations. Handing the routing decision to the model, in the text it already produces, is a cheaper fix than another retrieval layer bolted on top.
2. Harness-of-Harness
Coding agents are good for a session and unreliable for a week. Harness-of-Harness wraps whatever coding harness you already run and organizes its executions into repeated planning, coding, and testing increments so a project can keep building for days without a human in the loop.
Three roles around one artifact: A Project Planner turns the spec and the accumulated test evidence into a new development plan, a Developer builds against that plan, and a QA Tester evaluates the result across quality dimensions and returns an evidence bundle. The next iteration starts from that bundle rather than from a transcript.
Testing gets split in two: Implementation-time testing stays separate from independent evaluation, which keeps the agent from grading its own work with the same tests it wrote to pass.
Constraints sit on the outputs: The loop balances repair against capability growth and scopes work into small verifiable steps, so a long run does not stall on one broken subsystem or wander into unplanned features.
Why it matters: Across GameCraft-Bench, FrontierSWE, and ProgramBench with three different harness and model pairs, it averages a 52.25% relative gain over the standalone harnesses after three iterations, peaking at 82.86%. Since it sits on top of an existing harness, the pattern is portable to whatever you already run.
3. WikiSkill
Karpathy popularized the idea of an LLM wiki. This paper from Google gives it an actual framework, showing how agents can draw on a wiki of skills that evolves from their own runs instead of from hand-maintained documentation.
Three layers with different write rules: Immutable execution traces are written once and never edited. A wiki layer of structured patterns and evolution logs compounds and never resets. A skill layer sits on top and gets reversible, conditional updates.
The loop closes on failures: An inference agent executes rollouts, a wiki maintainer runs root-cause analysis on the traces, a skill proposer drafts updates from the wiki and the traces, and a gating step evaluates the candidate on a validation set before anything ships. Bad updates roll back.
Evolved skills transfer: The method is model-agnostic, and skills evolved on one model carry over to smaller models that sometimes outperform bigger ones running without skills.
Why it matters: Most teams maintain skills by hand and discover the gaps in production. WikiSkill turns agent runs into the maintenance signal, and the practical takeaway generalizes past the paper. Build a persistent knowledge base across your projects, then use it to keep skills tuned.
4. SKILL.state
Long-running agents slow down and start poisoning their own context, and both symptoms trace back to one design choice. Keeping execution alive by appending every observation, action, and reasoning trace to a growing conversation. Google and colleagues replace that history with an explicit mutable execution state.
The prompt stops growing: At each step, the model sees only the immutable skill specification, the current structured state, and the latest observation. Prompt size goes from O(T) in the number of steps to O(1).
Reasoning is discarded on purpose: Intermediate reasoning gets thrown away the moment it produces a validated state update, expressed as a JSON patch. What survives is the state, not the narration that produced it.
Accuracy and cost move together: Across several datasets, models, and execution environments, task accuracy improves while cumulative token consumption drops. Baseline runtimes hit quadratic context growth on long-horizon warehouse tasks where SKILL.state stays bounded.
Why it matters: The abstraction is architecture-agnostic and ports into existing skill runtimes, so this is closer to a change you can make than a system you have to adopt. If your agent degrades past a few hundred steps, this names the reason.
Message from the Editor
We just released Write better with Claude Fable 5.1, a hands-on DAIR Academy lab on getting better prose out of the model. Free for a limited time.
5. CORAL
Meta ran an agent harness against a live production recommender serving billions of people and reported A/B results. Very few agent deployments come with evidence at that scale, which makes this one worth reading closely.
Continual optimization is the job: Sustaining a recommender means revisiting retrieval, ranking, and serving choices as content, user behavior, and upstream models shift. Human engineers test those changes through online experiments, which is slow enough that parts of the system go unrevised for long stretches.
The loop is observe, reason, optimize, measure: Each cycle the agent reads operating signals, reasons over a memory of past decisions and their measured outcomes, then invokes tools including a numerical optimizer. The policy improves in context from its own prior actions with no parameter updates.
Guardrails carry as much weight as the agent: A constrained optimizer holds every change inside a fixed operating budget before anything deploys. The bounded change budget is why this can run against production at all.
Why it matters: Across two large social platforms, the same harness improved engagement at no additional serving cost on one and reduced serving cost without degrading engagement on the other, with performance improving as the loop iterated. The guardrail design transfers to other domains more readily than the recommender specifics do.
6. E-Commerce Bench
Agent benchmarks usually end when the session does. The Qwen team built one that runs an agent through a simulated 365-day year operating several online stores at once, then scored 18 frontier models on seven dimensions.
Four layers under the agent: An agent loop layer handles turn-based control, context management, and persistent memory. A tool layer covers store operations, supplier negotiation, inventory, and finance. An environment layer runs a dynamic economy with seasonality, promotions, disasters, and supplier bankruptcies. A data layer supplies 12 store types, 576 suppliers, and 6,886 products.
No model dominates: GPT-5.6 Sol earns the most, growing a 100,000 opening stake into 1,431,425, then ranks 16th of 18 on fraud avoidance and trails Fable 5 on operational efficiency. Profit and judgment come apart.
Open weights hold up: Qwen3.8-Max-Preview leads the open-weight field at 416,252, 38% above GLM 5.2 (high), and shows the strongest learning over the horizon by progressively bargaining suppliers down across repeated orders.
Why it matters: A year-long simulation surfaces failure modes a single-session eval cannot reach, including the slow ones around fraud exposure and margin discipline. If you evaluate agents on anything longer than one session, the scoring design here is the useful part.
7. AI Research Preference Models
A research agent can propose far more experiments than it can afford to run, so idea generation was never the bottleneck. Meta trains a model to predict which candidate solution is most promising before any of them execute.
Two variants on frozen backbones: An inference-only model reasons over candidate plans, code, and previously executed solutions in the search tree. An agentic model goes further and runs small-scale pilot experiments before committing budget to a candidate.
It slots into the search loop: At each node, the agent generates candidate mutations, the preference model picks the child to expand, and the tree updates from the result. Nothing about the underlying agent changes.
Less time and less compute: Both variants reach the unguided agent’s 24-hour performance in roughly 15 hours using less than two-thirds of its execution budget, and average normalized score on AIRS-Bench moves from 0.684 to 0.711 and 0.729.
Why it matters: Once compute is the binding constraint on a research agent, deciding what not to run matters as much as running well. The same selection pattern applies to any agent choosing among expensive branches, not only ML research.
8. Trace as State
Where you put a reasoning trace changes long-context accuracy by up to 50 points. Transformers process causally, so a task state discovered late cannot guide reading that already happened, and Trace as State puts the collected trace before the long-context block on a fresh pass instead of appending it after. On GraphWalks Parents, DeepSeek V4 Pro Preview goes from 29.2% on the initial pass and 43.0% with the matched append control to 81.8%, and GLM-5.2 goes from 66.4% and 83.2% to 100.0%. It wins in 26 of 27 reported combinations of model, task, and metric with no architecture change.
9. Selective Forgetting
Graph memory is widely assumed to beat flat retrieval for long-term agents, and this paper tests it with the candidate-generation budget held fixed at five retrieval roots. On LongMemEval, the graph scores token F1 0.42 against 0.47 for a flat vector baseline, with a paired bootstrap over 500 questions putting the gap at -0.050. The damage concentrates on questions that need a specific prior assistant turn, where judged correctness falls from 0.911 to 0.607, because splitting a turn into entities discards the surface form. The forgetting module fares much better, pruning 9.8% of nodes from a persistent 27,021-node graph with token F1 unchanged.
10. Runtime-Independent Persistent Agents
We describe an agent by whatever model and harness it happens to run on, which works for one session and says very little about an agent running for months across a new model, a new harness, or a new machine. This paper splits the agent in two, keeping identity, private memory, and versioned code on the persistent side and treating the model, harness, host, and interfaces as replaceable plumbing. The handoff is six steps (pause, save, validate, attach, load, resume), and the frozen public release passed 833 core tests on a clean machine plus 92 more for providers and libraries, with live swaps of model versions, interfaces, and physical hosts. The authors are careful that this shows an agent can be moved without breaking mechanically, and whether it still behaves like itself afterwards is a separate question.
Treating declarative attention as tool calls is a clean architectural bypass for serving bottlenecks. Trading a 2-point accuracy hit to halve KV cache reads transforms unit economics for long-context agents, avoiding the latency penalty of auxiliary retrieval layers.