AI Newsletter

🤖 AI Agents Weekly: GPT-6 Cyber, Weight-Space Programming, Claude Dreaming, Exo, METR's AI R&D Assessment, SWE-2 Flash, Mistral Studio, and More

Sat, 07 Nov 2026 14:31:24 GMT

In today’s issue:

OpenAI ships GPT-6 Cyber
GPT-6 Astra edits Qwen’s weights directly
Anthropic details Claude’s dreaming memory
Exo agents rewrite their own harness
METR measures AI R&D acceleration
NVIDIA questions long-context agents
Cognition launches SWE-2 Flash
Mistral Studio adds managed agents
Harness Leaderboard compares nine harnesses
Benchmark tests agents as teammates

And all the top AI dev news, papers, and tools.

🥇Top AI Papers of the Week

Sun, 01 Nov 2026 17:34:56 GMT

1. DecisionRAG

Whatever a retriever misses never reaches the generator, and most retrievers still rely on keyword matching or fixed embeddings. Researchers from Cornell and ASAPP propose DecisionRAG, which replaces the first-stage retriever with a decision model that walks the corpus from broad topics down to documents and passages.

Hierarchical navigation: At each level, a decision model such as Jev scores every candidate in one forward pass without generating tokens, then keeps the most promising branches. Under a balanced hierarchy, the number of sequential decisions grows logarithmically with corpus size.
Shared context: Judging candidates together lets the model compare them. This adds 7.7 R@1 points on MultiDoc2Dial and 6.5 Hit@1 points on Natural Questions over judging them separately.
Results: With no task-specific training, DecisionRAG beats dense retrieval plus an 8B reranker by 13.8 R@1 points on MultiDoc2Dial and 17.4 Hit@1 points on Natural Questions, which searches 2.68 million Wikipedia paragraphs. Retrieval takes 0.7 to 1.8 seconds and 0.2 to 2.3 cents per query.
Why it matters: A Qwen3-8B judge trained on in-domain data reaches 60.7 R@1 on MultiDoc2Dial, 5.7 points above the best compared published task-trained retriever. The method depends on a well-organized corpus hierarchy, and a branch pruned early stays lost unless budgets grow or dense retrieval adds candidates.

Paper | Tweet

Message from the Editor

We’re excited to invite extended abstracts for Humanoids at the Edge, a full-day Space Robotics workshop at IEEE-RAS Humanoids 2026 on December 7 in Santa Clara, CA. If you work on humanoids for hazardous operations or space exploration, we’d love to see your research, work in progress, negative results, or field reports. Abstracts of up to 3 pages are due November 6, 2026, at 11:59 PM AoE.

Submit an Abstract | Workshop Website

2. Unified Training

Foundation models usually train in separate stages (pretraining, midtraining, supervised fine-tuning, and RL), each with its own recipe. Researchers from Carnegie Mellon, Johns Hopkins, and Aurora Innovation show that all of these stages can run under a single likelihood-based algorithm, which they call unified training.

One shared loss: Suitable RL objectives are derived as maximum-likelihood fitting to model-generated targets, so RL generations and static data share one loss and one trainer. The design problem becomes which data to train on, in what proportions, and when, with staged training as one special case.
Reasoning puzzles: A 124M model trained from scratch beats staged training on the RL tasks and on larger puzzles it never saw in midtraining or RL. Under a fixed compute budget, unified training has the highest accuracy at the smallest and largest budgets, while staged training leads at intermediate budgets.
Math RL: On a 0.76B model, mixing in 0% to 5% midtraining data keeps math accuracy similar while retention improves. Coding accuracy drops as the mix grows.
Why it matters: After math training, all unified models beat staged training on final coding accuracy despite starting lower, and the 5% mix does best on all four metrics. The experiments are small-scale, and the authors have not found a mixture or schedule that works best across the board.

Paper | Tweet

3. HarnessMM

Agent harnesses often call the model again after tool feedback even when an earlier call already settled the next action. Researchers at Tsinghua University and Microsoft Research Asia introduce HarnessMM, which reuses those settled decisions and tunes harness configurations through recursive self-improvement while keeping model weights fixed.

Executable Decision Graphs: These graphs store exact actions, literal arguments, causal dependencies, and public guards, so a resolved decision can run again at a later tool boundary.
Guarded reuse: Guarded Decision Reuse activates a stored decision when observed tool receipts satisfy its guards, and Certified Callback Substitution executes it through the native interface and records that the slow call was removed. New decisions, unsupported evidence, and abstentions go back to the original model.
Results: On the same 98 HumanEval test tasks, DeepSeek Harness rises from 71.43% to 85.71% success while tokens per task fall from 96.28k to 11.62k, an 87.93% saving. Codex holds 90.82% success with 29.54% fewer tokens, and a separate MBPP ablation measures 19.52% lower cost than retained callbacks.
Why it matters: DeepSeek Harness drops from 954 to 415 paid model calls on HumanEval, which gives teams a reason to count repeated decisions before paying for a bigger model. Savings depend on provider cache accounting and on how many actions are already resolved, and authoring, selection, and recovery can outweigh the avoided calls.

Paper | Tweet

4. EMMA

Methods that evolve multi-agent systems often follow the backbone model’s habits rather than observed failures, so one backbone accumulates skills while another spawns agents. Researchers from UC San Diego and Amazon present EMMA, which stores a multi-agent system’s configuration as episodic memory and restricts how that memory can change.

Three memory levels: A controller plans each task one step at a time and draws on routing memory. Specialist agents inherit a generalist prompt, and skills hold short per-step procedures, all as text run by one fixed LLM.
Scoped updates: After a failure, a reflector assigns the fix to the scope that owns it and proposes one edit there. Guards that do not depend on the backbone keep every accepted edit scoped, incremental, and bounded.
Results: Across KramaBench, AppWorld, and BBEH with five backbones, EMMA has the best overall performance on every benchmark against ACE, GEPA, EvoMAS, and ADAS, up to 32.5% over the strongest baseline. It ranks first in 17 of 20 settings and uses 17 to 38% fewer training executions than the most efficient baseline.
Why it matters: Multi-agent search baselines fall sharply on open-weight models. On the AppWorld challenge, EvoMAS scores 89.0 with Opus 5 and 7.2 with GLM-5, while EMMA’s weakest backbone still reaches 61.2. The authors note that accepted edits persist even when a task stays unsolved, so ineffective entries may remain.

Paper | Tweet

5. A Heart Means Recursion

Researchers from Google DeepMind and Stanford find that simple visual symbols can change how vision-language models behave on unrelated tasks, and that the models do not report the influence. With no image, Claude Opus 4.7 and GPT-5.4 always write iterative code for inorder binary tree traversal.

Visual steering: A red heart in context moves Claude Opus 4.7 and GPT-5.4 to recursion in 100% of samples, and a yellow checkmark moves Gemini 3.1 Pro to 90%. The effect matches or approaches directly instructing the model to use recursion.
Images over captions: Text captions of the same symbols do not reproduce the pattern, and random or naturalistic images steer less. The same 288 colored shapes also shift writing style and answers to simple preference questions.
Hidden influence: For GPT-5.4, 74.7% of thinking traces misattribute the symbol’s role. When images are inserted silently, Claude Opus 4.7 still reaches a full switch to recursion, and GPT-5.4’s traces never mention the image.
Why it matters: When models send images to each other, they choose shapes such as spirals and arrows that they and humans find intuitive, and these often fail to steer the receiver. Agents that read screenshots can change behavior in ways the reasoning trace will not show, although the tasks in this study are synthetic.

Paper | Tweet

6. Verification in Agent Harnesses

Harness builders have little evidence on where verification effort pays off. Researchers from Alibaba and Cornell compare 17 designs across seven frontier coding models on Terminal-Bench and SWE-bench Verified, spanning initial instructions, execution-time reminders, completion gates, and independent review. They also introduce VisualBench for expert evaluation of visual and interactive artifacts.

Instructions and reminders: Gains are modest and depend on the model. System-role instructions add 3.3 points on Terminal-Bench and 3.9 on SWE-bench, and system-role reminders add 3.1 to 3.8 points.
Completion gates: Early user rejection gives the largest gate gains at 6.0 and 6.2 points, but rejection designs cost 1.60x to 1.76x baseline on Terminal-Bench and 1.48x to 1.56x on SWE-bench. The authors recommend avoiding completion-time self-checking.
Independent review: A separate critic adds 5.9 to 9.5 points on Terminal-Bench at 1.13x to 1.25x baseline cost, and 3.9 to 6.6 points on SWE-bench at 1.00x to 1.04x. Extra review rounds or critics add up to 3.5 more points on Terminal-Bench.
Why it matters: The critic designs also lead on VisualBench, with net preferences of 13.2 to 23.8 points over the baseline, and reviewing the changes beats reviewing the trajectory there. Teams adding one verification step to a harness have a measured case for a separate reviewer.

Paper | Tweet

7. EmbeddingGemma 2

Multimodal embedding models adapted from large language models typically carry several billion parameters, which makes them expensive for on-device and latency-sensitive work. Google presents EmbeddingGemma 2, an open 744M model that maps text, images, audio, video, and mixed inputs into one vector space.

Modular design: A 167M vision encoder and a 305M audio encoder feed a 271M bidirectional transformer, so teams load only what they need. It runs at 271M for text, 439M as a vision-language model, and 577M as an audio-language model.
Training recipe: The model builds on the Gemma 4 family and learns from Gemini Embedding 2. Training runs in three stages, separating text-only from multimodal training and distillation from contrastive objectives.
Results: Across seven benchmark suites covering text, code, image, video, document, speech, and sound, it sets a new Pareto frontier, beating specialist models and models two to twelve times larger. MTEB Multilingual v2 reaches 61.36, and MTEB Code rises from 68.76 to 78.68 over its predecessor, while MTEB English v2 falls from 69.67 to 68.46.
Why it matters: The int4 version loses about 0.4 points on MTEB Multilingual, and teams can also lower the vision token budget or truncate embedding dimensions. That makes it a practical on-device option for agent memory and retrieval over mixed media.

Paper | Tweet

8. AgentBaton

Researchers from NVIDIA, HKUST, and UIUC study one-time handoffs from an expensive, capable model to a cheaper one within a long-horizon agent task, and their AgentBaton detector learns when to switch from patterns in task progress. Across 11 model pairs on DeepSWE v1.1 and Terminal-Bench 2.1, it cuts API cost by 65.9% on average while largely preserving accuracy, with gains of up to 8.8 points over capable-only runs. The cost figures assign zero cost to locally deployable models, and handoffs in the other direction save little or nothing.

Paper | Tweet

9. Agentic Backdoors

Researchers from the Anthropic Fellows Program, Anthropic, UC Berkeley, and UIUC show that poisoning 0.1% of the pretraining corpus can plant a remote code execution backdoor that survives a clean post-training pipeline into a CLI agent. On a 4B model, an ordinary file path in the user’s request reaches a Pass@32 attack success rate of 92.7%, while clean prompts produce the payload 0.0% of the time. Attack success rises with model size, and at a 0.0005% poison rate an injected trigger still fired on 1.4% of prompts in a single-seed run.

Paper | Tweet

10. System One Rerankers

Researchers from the University of Passau and IT:U test whether decision fine-tuning makes a better reranker than plain reranker fine-tuning, using six Qwen backbones from 0.6B to 27B on ten TREC DL and BEIR collections. Reranker fine-tuning wins by 5 to 29 nDCG@10 points from 0.6B to 9B, and the two tie at 27B, while decision fine-tuning adds nothing over the untuned model up to 9B. The calibration advantage of decision models depends on how the question is worded, and it does not make up for a worse ranking.

Paper | Tweet

🤖 AI Agents Weekly: Gemini 4 Carbon, GPT-6.1 Terra, OpenAI's Three Discoveries, Mistral Large 4, Axiom CFSG Proof, Qwen Investigation, Genie 4, and More

Sat, 31 Oct 2026 14:39:05 GMT

In today’s issue:

Google previews Gemini 4 Carbon
OpenAI ships GPT-6.1 Terra
OpenAI models refute Exponential Time Hypothesis
Mistral opens Large 4 weights
Agent swarm formalizes 15,000-page proof
Cohere flags Qwen upload attempt
Anthropic measures agent influence on experts
Cognition launches FrontierCode 2.0
DeepMind unveils Genie 4
Pretraining poison backdoors CLI agents

And all the top AI dev news, papers, and tools.

🥇Top AI Papers of the Week

Sun, 25 Oct 2026 16:14:31 GMT

1. Object-Oriented Harness

An agent harness is executable code that sets the prompts, tools, and control flow around a model, and a single global harness struggles when tasks require different execution strategies. Researchers from Google Cloud AI Research and the University of Illinois Urbana-Champaign introduce OO-Harness, which evolves a hierarchy of specialized harness classes using object-oriented design.

Class hierarchy: During training, an evolution agent reads execution records and builds a family of specialized harnesses. Each one is a subclass of the base harness or of an existing specialized harness, and it overrides only the methods its task cluster needs.
Lessons and routing: Design lessons record which changes helped and which ones failed. At test time, a router reads the task and the base run, then picks a subclass or keeps the base result, using routing lessons gathered during training.
Results: With the same Gemini 3.5 Flash executor, AutomationBench rises from 61.6% to 77.4%, Workspace-Bench from 25.5% to 39.5%, and strict pass on Toolathlon-GYM from 31.2% to 37.5%. OO-Harness beats Meta-Harness on all three benchmarks, while spending extra inference on best-of-K sampling or self-refinement does not reliably help.
Why it matters: Inheritance itself adds value. On Workspace-Bench, harnesses built as subclasses score 4.96 points higher than the same evolved code copied into flat classes, which gives teams building harnesses for mixed workloads a concrete reason to specialize instead of growing one global harness.

Paper | Tweet

Message from the Editor

Our new MCP server lets you search and explore our AI Papers of the Week index directly from Claude Code or Codex. Set it up with one command, npx @dair-ai/mcp setup.

Get Started

2. Gemini Agents Beat Minecraft

Researchers from Google DeepMind placed four Gemini 4 Argon agents in a sandboxed Minecraft survival world with one goal: defeating the Ender Dragon. They report what they believe is the first end-to-end autonomous completion of Minecraft by AI agents, using only the standard Mineflayer library with no pre-scouted seeds or game-specific tools written by humans.

Setup: Each agent controlled one player through Mineflayer and coordinated with its teammates through in-game chat and a shared memory. No one assigned roles or wrote game logic, and the agents planned, wrote, and debugged every program themselves.
The run: Starting from a random world on Easy difficulty, the team wrote 2,783 programs, died 605 times, and defeated the dragon in 27 hours and 14 minutes. Researchers watched on a live dashboard and never needed to intervene.
Team strategies: The agents divided the work, shared what they learned, and recovered each other’s items after deaths. A fifth Observer agent watched the session for cheating or specification gaming and found none.
Why it matters: Winning required keeping one plan coherent across thousands of dependent steps for more than a day, the same long-horizon coding and coordination that real software and enterprise tasks demand. The authors clearly state the limits: a single run, Mineflayer exposing hidden game state, Easy difficulty, and the model’s prior knowledge of Minecraft.

Paper | Tweet

3. DiscoveryRSI

Scientific discovery depends on turning worthwhile hypotheses into practical investigations, and learning from that evolving research process is hard. Researchers from PhAI Labs, CUHK, Stanford, Harvard Medical School, and colleagues present DiscoveryRSI, which applies recursive self-improvement to hypothesis generation across four life-science domains.

Hypothesis trees: The system grows trees of hypotheses with multi-agent evolutionary search and compiles the selected investigations into executable Harbor tasks. The authors define a valuable hypothesis as an evidence-grounded claim about a consequential uncertainty, paired with a feasible investigation, explicit decision criteria, and alternative explanations.
Three learning mechanisms: Hypothesis credit optimization attributes scientific assessments to the research contributions behind them. Harness replay finds productive strategies and recurring failures in the research workflow, and rediscovery applies accepted improvements to new investigations.
Results: Automated hypothesis quality rises from 4.86 for the base model to 5.39 after two rounds of self-improvement, with the largest gains in falsifiability and data resolvability. The 27B model’s hypotheses match research published after its training cutoff 6.3% of the time, compared with 2.5% for GPT-6 and 2.3% for Claude Opus 5.
Why it matters: Preliminary expert review rates DiscoveryRSI-27B above GPT-6 Luna on hypothesis importance and on whether claims are plausible and evidence-bounded. The paper also releases DFM-Bench for scoring hypotheses, revisions, and whole research runs.

Paper | Tweet

4. Cache Engineering for Agents

As agent trajectories grow, KV cache I/O and storage become the dominant cost. Context engineering trims or summarizes history, but changing the trajectory prefix invalidates the cache after it, and the retained context has to be prefilled again. Researchers at Tsinghua University and CUHK propose cache engineering, where the agent directly controls its active KV cache.

Two cache operations: A drop operation excludes selected cache entries from future attention, and a repos operation adjusts the position encodings of the keys that remain. The trajectory text stays unchanged, so we don't need to prefill anything again.
AKV serving engine: Identical token sequences can produce different cache states under different sequences of operations, so prefix matching is not enough for correct cache reuse. AKV exposes a stateless interface compatible with existing serving APIs and manages stateful reuse, eviction, and restoration internally.
Results: A rolling drop of old tool responses scores 1.7 points higher on average and costs 27.7% less than threshold-triggered summarization. With AKV, it reaches up to 1.2x output throughput and 1.5x faster P95 latency.
Why it matters: Recursive self-improvement of cache policies cuts cost by another 7.1% over expert design. Cost control for long-running agents can happen at the cache layer, below the prompt, and the code is open source.

Paper | Tweet

5. JevAgentHarness

Agent harnesses call a large LLM at every step, which makes long tasks slow and costly, yet most of those calls end in a multiple-choice decision such as which tool to call next. Researchers from UIUC, Princeton, and Google study how a harness can hand these choices to a decision model like Jev with little loss of success.

AgentDecisionBench: The benchmark tests decision models from isolated questions up to control of a running agent. The model most accurate on isolated questions solved only 69.5% of agent tasks, and delegating tool choices without a fitted confidence threshold lowered success by 19.0 points.
Fitted thresholds: JevAgentHarness sends each routine choice to the decision model and uses its answer only when confidence clears a threshold fitted on the agent’s own trajectories. Below the threshold, the LLM decides. With fitted thresholds, tool and argument cascades cut cost by 14.2% without changing the outcome of any of 500 tasks.
AgentDecision-4B: Existing decision models never see the states an agent reaches after its own mistakes, so the authors train an open 4B model on those states with Jev’s answers as labels. On tasks unlike its training data, the agent solved 91.5% with AgentDecision-4B and 82.0% with Jev.
Why it matters: On tasks like their training data, 4B models trained this way made agents 81.1% to 89.0% cheaper and up to 2.5x faster while staying within 3 points of task success.

Paper | Tweet

6. Evolving Agent Interfaces

Computer-use agents act through interfaces that people design by hand, so an agent may type a spreadsheet cell by cell when one line of code would do. Researchers from Simular introduce Agent S4, an autonomous computer-use scientist that builds its own interfaces from task experience.

Meta-agent: A meta-agent examines task agents’ trajectories on synthetic training tasks, with no success labels, and builds and revises interfaces along with notes on when to use each one. Both live in a repository the task agent draws from.
Population-based selection: Evolution keeps the repositories that perform best on validation tasks the meta-agent never sees, which favors changes that carry over to new tasks.
Results: With Qwen3.8-27B and the evolved interfaces, Agent S4 reaches 21.3% on OSWorld V2, 3.8x the same model with fixed interfaces and a new state of the art for open-source computer-use agents. That is above GPT-5.5 at 13.0% and Claude Opus 4.8 at 20.6%, at about 4.3% and 1.5% of their costs.
Why it matters: On ScienceBoard, the evolved interfaces raise success from 41.4% to 58.6% with the same model. The authors argue that interface design should be an agent capability, a source of improvement that complements better models and harnesses, and the code is open source.

Paper | Tweet

7. Self-Evolving Continual Learners

Deployed agents face a steady arrival of new knowledge, tools, and workflows, and they are expected to learn new tasks without forgetting earlier ones. Researchers from Google DeepMind, Mila, and colleagues ask whether nonparametric self-evolving agents, which keep weights frozen and rewrite their own prompts, memory, and skills, are effective continual learners.

Drifting streams: The study builds four task streams from BIRD, BFCL, and ScienceWorld that shift in topic, workflow, or domain. It evaluates ReasoningBank, GEPA, and Meta-Harness, covering both experience retrieval and self-modification.
Plasticity costs stability: Self-evolution improves aggregate performance on most streams, but higher plasticity consistently comes with more forgetting. Across all 12 method and scenario pairs, plasticity and stability show a correlation of r = -0.72.
Two failure mechanisms: Self-modifying methods apply global edits to a shared prompt or workspace, which interferes with unseen tasks and overwrites older knowledge as the stream shifts. Similarity-based memory retrieval keeps updates more local, but it still retrieves memories from other domains and suffers collisions when similar queries need conflicting workflows.
Why it matters: The authors conclude that current self-evolving agents remain incomplete continual learners. Static benchmarks hide both problems, so teams building self-improving agents should test them on streams that change over time.

Paper | Tweet

8. Terminal-RSI

Researchers from Tencent train terminal agents by alternating two phases over five stages starting from Qwen3.8-27B, fine-tuning on rewritten versions of verified trajectories and then running PPO with a critic inherited from the previous stage. The four-suite Terminal-Bench average rises from 20.68% to 50.58%, with 86.52% on Terminal-Bench 2.1 and 79.00% on Terminal-Bench Hard. A reward audit found that under a dense progress reward, failed runs collected 50.09% of the reward, and separating strict success from partial credit cut that share to 28.72%.

Paper | Tweet

9. Transcoder Features Are Neurons

Researchers from Anthropic and Georgia Tech find that many active transcoder features in late layers are close copies of single MLP neurons, measured across 13 open-source transcoders. These neuron-aligned features are the only ones with a stable link to the underlying MLP, while the other features vary more between training runs, do not match the MLP’s Jacobian, and move less from their random initialization. The authors conclude that MLP neurons are a stronger basis for interpretability than commonly assumed, and that the non-neuron features need better validation before they are used to explain model behavior.

Paper | Tweet

10. MemoryTax

This short study runs four memory methods (full context, BM25, Mem0, Zep) and three coding agents (Pi, Codex, Claude Code) on one 419-turn LoCoMo conversation with three models, recording the cost of every rollout. Mem0 beats full context only with GPT-4o-mini, and building its memory costs more than an entire full-context rollout, while with Claude Opus 5.5 the Pi coding agent searching the raw history scores 99% for under half the cost of full context. Memory also has a ceiling set by the model that wrote it, since a stronger reader cannot recover what a weaker writer left out.

Paper | Tweet

🤖 AI Agents Weekly: Claude Duet, Kimi K3.1 Pro, MiniMax M3.1 Flash, Recursive Flint, DeepSeek DeepInfer, Ramp Laminar, Mercury 3, and More

Sat, 24 Oct 2026 16:49:07 GMT

In today’s issue:

Moonshot launches Kimi K3.1 Pro
Anthropic previews Claude Duet
OpenAI coordinates critical PHP fixes
MiniMax opens M3.1 Flash weights
Recursive ships local coding model Flint
DeepSeek open-sources DeepInfer
Ramp details its Laminar harness
Inception launches diffusion LLM Mercury 3
Databricks launches MemCurrent agent memory
Naive RAG beats agentic memory

And all the top AI dev news, papers, and tools.

🥇Top AI Papers of the Week

Sun, 18 Oct 2026 16:39:01 GMT

1. Quantum Circuit Discovery

Many quantum algorithms rely on a small set of computational primitives, and compiling those primitives into quantum circuits is hard because the computation must be reversible. Researchers from Anthropic, Harvard, and QuEra Computing pair an LLM that proposes circuit designs with an independent evaluator that verifies and scores every candidate.

Evolutionary search: The search runs over circuit-generating programs with OpenEvolve, using Claude Mythos 5 to propose architectures and program rewrites. Each search starts from a hand-written task specification and a blank program, and the best designs seed the next round.
Verified circuits: The evaluator checks each circuit for correctness before scoring it by Toffoli count and peak qubit count. Every reported gain is a circuit that passed this check.
Results: On seven of eight tasks spanning numerical computation, chemistry, optimization, quantum simulation, and number theory, the discovered circuits use fewer Toffoli gates and fewer qubits than the best-known designs, cutting the combined cost by 4.1x to 39x. For a Reed-Solomon decoder, the search switched to the Berlekamp-Massey recurrence and lowered the Toffoli count from 5.1 million to 440,000.
Why it matters: On the eighth task, the search found a new reversible architecture for prime-field modular inversion that makes divsteps, a classical algorithm previously impractical for reversible integer arithmetic, usable and improves the Toffoli-qubit trade-off. The authors suggest that some apparent costs of quantum arithmetic reflect limits of existing reversible constructions rather than of the algorithms themselves.

Paper | Tweet

Message from the Editor

We are excited to release our new MCP server that lets you search and explore all the past papers in our AI Papers of the Week index directly from Claude Code or Codex. Set it up with one command, npx @dair-ai/mcp setup.

Get Started

2. LongHarness

Agents that reason over document collections larger than their context window usually keep retrieved evidence and their evolving conclusions mixed into one growing interaction history. Researchers from Shanghai AI Laboratory, Fudan University, and colleagues present LongHarness, a model-agnostic harness for corpora of 100M tokens and more that keeps evidence and conclusions as explicit state.

Two failure modes: The authors identify unbounded exploration, where retrieval keeps expanding the history without closing the information gap that matters, and evidence-state drift, where earlier evidence or later corrections stop reaching the current conclusion.
Evidence-Conclusion Coevolution: Open conclusions decide what to retrieve next, and each new piece of evidence strengthens or revises the conclusions that asked for it. An evidence lifecycle step keeps accumulated evidence current and traceable throughout the interaction.
Same model, much higher scores: With GLM-5.3-Flash, exact match on OfficeQA Pro rises from 15.8% to 60.2% on V1 and from 4.4% to 61.1% on V2 compared with direct reasoning. LongHarness beats Claude Code by 12.0 points on V1 and Codex by 18.9 points on V2, and Qwen3.8-Flash reaches 61.7% on V1.
Why it matters: The gains come from the harness, with the backbone held fixed. Teams building agents for long-context work over large internal corpora can get large improvements by managing evidence explicitly instead of relying on a growing chat history.

Paper | Tweet

3. Hybrid Reasoning Agents

Today’s LLM agents write out every reasoning step as text before they search, run code, or take an action, and those steps cost tokens and time. Researchers from Stanford, Together AI, and colleagues introduce Hybrid Reasoning Agents, which reason internally in latent space and switch to text only to call a tool or give an answer.

HybridLink: A lightweight module moves the model between latent and text modes within a single generation process. A continuous working memory keeps both kinds of context across turns, tool calls stay in plain text, and the latent steps can still be inspected.
Two-stage training: HybridSFT first teaches the backbone to work with HybridLink during tool-integrated generation. HybridRL then teaches the model when to think in latent space and when to act through text.
Results: Across 3 model scales and 11 benchmarks in math, science, medicine, search, and agentic reasoning, it improves over frontier LLM agents and agentic frameworks, both text-based and latent, by 10.4% on average. The 14B model beats the strongest agentic baseline by 17.4% on agentic reasoning tasks.
Why it matters: The agents use 35.5% to 54.7% fewer tokens, run 1.8x to 2.6x faster, and cost 2.7x to 3.7x less. Researchers have mostly studied latent reasoning without tools, and this work shows how to combine its efficiency with standard tool use.

Paper | Tweet

4. Harness^2

Recursive self-improvement of agent harnesses usually depends on a verifier, and open-world tasks are new at test time, so no ground-truth checker exists. Researchers from Google Cloud AI Research and Northwestern University introduce Harness^2, a plug-and-play framework that improves the harness at test time through two connected levels of recursion.

Task-level recursion: A contrastive Propose-Probe-Compose step proposes several edits to the harness for the current task, tests them against each other, and keeps the combination that works best. This guides edits reliably without a ground-truth verifier.
Harnessing-level recursion: Lessons from those edits update a second, continual improvement harness that the agent carries to future tasks, so improvements carry over instead of staying task-specific.
Results: A single step improves GLM-5 and Gemini 3.5 Flash over their base harnesses in every configuration tested, with gains of up to 11.5 points on WorkBuddy-Bench, 4.5 points on JobBench, and 11.8 points on LAB. Running five candidate edits in parallel adds another 2.9 to 3.9 points on WorkBuddy-Bench.
Why it matters: ReasoningBank, a memory baseline, fell up to 6.6 points below the base harness on coding tasks in the same comparison. For teams evolving their own harnesses, the paper shows that test-time harness edits can scale with more recursion budget even when no verifier is available.

Paper | Tweet

5. Scaling Discovery Requires Forgetting

Automated research with coding agents can now run for days on a single problem, yet the search often stops improving early. Researchers from UC Berkeley, Stanford, and Bespoke Labs show that the fix is to make the agents forget.

The plateau: Letting one agent iterate longer, running agents in parallel, and letting parallel agents share candidates all plateau as history accumulates. Each agent anchors on its own past attempts and makes fewer, smaller edits, so extra budget yields little improvement.
Forgetting: The method periodically discards every agent’s session and the candidate history, then restarts the team from the best candidate found so far. The authors implement this in a team of agents that communicate.
Results: Across four tasks in heuristic programming, kernel optimization, and model training, forgetting gives up to 15% over parallel agents and up to 39% over a single agent with the same budget. On Anthropic’s VLIW kernel take-home, the team with forgetting reaches 1,077 cycles, against 1,172 for four parallel agents and 1,262 for one agent.
Why it matters: Most research-agent designs try to keep as much history as possible. This paper suggests that, for open-ended discovery, what an agent is allowed to remember matters as much as how much compute it gets.

Paper | Tweet

6. ReHarness

Agent memory harnesses usually only write forward, so a lesson goes into the bank and is never checked against whether it helped. Researchers from MIT, Meta, and Yale propose ReHarness, a recurrent harness for agentic continual learning that adds backward revision to the usual forward read and write.

Backward revision: After each task, ReHarness uses the finished trajectory as feedback on the specific reflections it retrieved and rewrites them. Feedback flows backward through the textual harness state, much like a recurrent update.
Strictly online: The method runs under a streaming protocol with no replay buffer or validation set. Add and delete operations alone keep a reflection bank tidy but ignore downstream outcomes, while ReHarness corrects lessons based on how they performed.
Results: Across three continual-learning benchmarks with 16 tasks and three backbones, ReHarness beats raw-context, memory, reflection, and prompt-optimization baselines. The gains stay significant after multiple-comparison correction.
Why it matters: Agents running over long interaction streams face distribution shifts, and stored lessons can become overgeneralized or outdated. The analysis shows that ReHarness produces source-grounded revisions that fix such lessons and improve both stability and plasticity.

Paper | Tweet

7. The Agentic Scientist

Fully autonomous research agents tend to have a narrow range of ideas and hill-climb myopically. Researchers from Sakana AI introduce The Agentic Scientist, an end-to-end distributed pipeline that lets human researchers run computational research alongside modern coding agents.

Staged pipeline: The system splits a project into task drafting, ideation, planning, sandboxed experiments, baselines and ablations, analysis, and report writing. Each stage runs on a coding agent that verifies its own work.
Meta-controller: A controller manages many research agents in parallel and checks every stage against a rubric. The same orchestration layer can be reused across domains with different execution environments, coding harnesses, and evaluation metrics.
Accepted paper: As a co-scientist, a development version of the system helped write a paper accepted at ALIFE 2026 as a main-conference talk, after human verification and edits. The system can also run fully autonomously, and the authors apply it to open machine learning problems across several domains of computational research.
Why it matters: The ablations show that reliable scientific autonomy depends on the cross-agent orchestration layer as well as on the base model. It is a useful reference for anyone building multi-agent systems around coding agents.

Paper | Tweet

8. GitSwarm

Researchers at Meta Superintelligence Labs and colleagues built GitSwarm, where hundreds of asynchronous agents share one Git repository, and each contribution is a commit that records which earlier commits, on any branch, it builds on, with no central planner assigning work. With GPT-5.5 Codex workers, it solves all 30 IMOProofBench-Advanced problems in one run and scores 79.4% on ProgramBench, up from 73.1% at 100 workers to 79.4% at 500, compared with 65.1% for a single Codex agent at a similar budget. Later workers build on 94.7% of published contributions, and 70.1% of failed research commits are cited by later accepted work.

Paper | Tweet

9. LoGRA

NVIDIA researchers present LoGRA, an RL post-training method that updates all of a model’s weights while using less memory than LoRA by compressing each weight gradient into a low-rank sketch redrawn every step and adding predicted-KL step control to keep updates within budget. At 1.5B it averages 7.2 GiB of training memory against 13.2 GiB for rank-256 LoRA with similar Pass@4, and at 7B it cuts average training memory per GPU by 45.7% with peak accuracy close to dense Adam. It also trains a 27B model for more than 1,100 steps on a single eight-GPU node, where dense Adam runs out of memory.

Paper | Tweet

10. AutoEnvScaling

Researchers from Microsoft and collaborators hand RL environment design to a proposer agent that works in a terminal, studies the rollouts of the model being trained, and builds new environments from them, with each round of rollouts guiding the next. Building environments in a terminal raises the share of valid environments up to 25 times over prompt-only generation at up to 75% lower cost per valid environment. With Qwen3.6-35B-A3B acting as both proposer and solver, Terminal-Bench 2.1 rises from 41.1 to 53.3, and the pipeline also generates environments for software engineering, computer use, and GPU kernel work.

Paper | Tweet

🤖 AI Agents Weekly: Muse Spark Open, Gemini Agents Beat Minecraft, OpenCode 2.0, Nemotron 3.5 Super VL, OpenRouter Armor, Claude OpenTelemetry, and More

Sat, 17 Oct 2026 16:03:13 GMT

In today’s issue:

Meta releases Muse Spark Open
Gemini Argon agents beat Minecraft
OpenCode 2.0 ships Code Mode
NVIDIA launches Nemotron 3.5 Super VL
OpenRouter launches Armor for tool calls
Claude Platform adds OpenTelemetry traces
DeepSeek ships V4.1-Flash-1017
Fish Audio opens Drama 3 weights
Forgetting helps autoresearch agents scale
Anthropic replaces git with Scion

And all the top AI dev news, papers, and tools.

🥇Top AI Papers of the Week

Sun, 11 Oct 2026 13:02:48 GMT

1. Harness Learning

An agent is defined by its model and its harness, the program that organizes model calls, tool use, and information flow. Researchers at CMU train a proposer model to revise the harness based on execution feedback, while the solver model’s weights never change.

Edits as updates: The authors frame harness adaptation as meta-learning over executable programs, where each harness revision plays the role of a weight update in gradient-based adaptation. The proposer reads a task, the current harness, and an execution report, then writes a code edit to the harness.
RL on harness scores: The proposer is trained with reinforcement learning, and the reward is the revised harness's task score. At test time, it refines the harness on a new task through successive executions, without updating parameters.
Small proposer, broad transfer: A trained 4B proposer beats its 35B teacher at single-step revision on Reasoning Gym, including task families it never saw in training. A proposer trained on HotpotQA keeps improving harnesses on MuSiQue and 2WikiMultihopQA, and policies trained on single revisions continue improving harnesses over multiple rounds.
Why it matters: Improving agents by editing harness code instead of weights is becoming its own AI engineering skill, and this work shows the skill can be learned and transferred to unseen tasks. It points toward agents that turn accumulated experience into general improvements without retraining the underlying model.

Paper | Tweet

2. CorpusMap

Agents that search large document collections usually see the corpus as a flat set of files, so a relevant document gives no hint of how it connects to others. Researchers from Microsoft and colleagues introduce CorpusMap, a navigation layer built around the entities that recur across a collection.

Entity pages: CorpusMap resolves mentions of the same entity across documents in advance and gives each recurring entity a page that aggregates what is known about it and links to every document that refers to it. The original documents stay in place.
Built once, reused per query: The agent reads a document, follows an entity to related documents, and avoids searching for the same evidence again. The links are built offline, so they are shared across queries instead of rediscovered at inference time. The map can be built without LLM calls and updated as new documents arrive.
Better answers, fewer tokens: Across 7 models and three benchmarks, answer quality rises 6.4 to 11.7 points over raw-corpus agentic search while input tokens drop 34% to 57%. CorpusMap also beats an LLM Wiki layer and three other navigation layers.
Why it matters: Enterprise questions often need evidence spread across emails, reports, and contracts in different folders. A precomputed entity graph gives agents structure to follow, which reduces both missed evidence and repeated searches.

Paper | Tweet

3. VeriHarness

A common practice with long-horizon agents is to sample several rollouts and trust the answers they agree on. Researchers at Google show that agreement can hide shared errors, while disagreement often points to the correct alternative, and they built VeriHarness to verify rollouts with the same base model.

Verifier from the generator’s model: VeriHarness gives the model the generator uses a workspace, evidence tools, and reusable verification skills. It needs no reference answers or grading rubrics at test time.
Two checks: A disagreement resolver checks competing claims against environment evidence. A consensus challenger tests claims that every rollout shares and looks for requirements they all missed. Their findings guide which artifact to select and how to revise it.
Results: Across five long-horizon workspace benchmarks and two frontier models, VeriHarness reaches the highest selection scores among the baselines tested. With evidence-backed revision, it adds 6.2 points over a single rollout with Gemini 3.5 Flash and 6.4 points with Claude Opus 4.8. Its verification skills also improve from feedback on failures.
Why it matters: Majority voting discards the minority answer, which is sometimes correct. The authors release about 26,000 rollouts across all five benchmarks and both models, produced at a cost of over $100,000, to support further work on agentic verification.

Paper | Tweet

4. HERMES

Software engineering agents on long-horizon tasks keep reconstructing program state spread across source files, configurations, tests, and dependencies, which leads to long interaction histories and context explosion. HERMES is a harness that turns repository components into active participants in the task.

Dev-Primitives: Each repository component is paired with a resident LLM that knows its own implementation and dependencies. The component gets an agent-native interface for natural-language reasoning, communication with other components, and localized self-modification.
Activation and diagnosis: A dependency-aware step decides which components to activate for a task, and a diagnosis step maps test failures and execution evidence back to the components that need changes.
Same model, different harness: On whole-repository migration, GPT-5.6 Sol goes from 6.5% to 31.0% when Codex is replaced with HERMES, at the same model and effort setting. Across four software engineering benchmarks, HERMES beats matched baseline harnesses by 12.4% on average.
Why it matters: With strong activation and diagnosis models, HERMES running Qwen3-8B Dev-Primitives stays within 4.5% of an all-GPT-5.6 Sol configuration on all four benchmarks and cuts inference cost on Terminal-Bench 4.0 by 26.2%. Most of the migration gain comes from the harness, so a harness built around your own codebase is worth the engineering effort.

Paper | Tweet

Message from the Editor

Our new DAIR Academy lab, Build a Website with a Pi Coding Agent, teaches you to build and refine a responsive one-page website by directing a Pi coding agent.

Get Started

5. MASS

Recursive self-improvement on open-ended tasks like research runs into a supervision problem because the outputs can exceed what even human experts can reliably assess, and there is no external checker. Researchers at Sakana AI propose Multi-Agent Self-Supervision (MASS), in which a single base model acts as the agent, evaluator, and optimizer.

Workflows as the search space: The base model proposes multi-agent workflows, runs them, and grades the results. An evolutionary search constrained by structural guardrails keeps the best-scoring workflows and settles on distinct roles and information routing for each task.
Alternating cycles: Each cycle pairs that workflow optimization with supervised fine-tuning on the model’s own multi-agent traces. The improved model then starts the next cycle as a better optimizer and grader, so the loop can keep bootstrapping the model’s capabilities.
Results: Two MASS cycles on Qwen3.6-27B give 1.2 to 1.6x higher performance per output token on four open-ended public benchmarks. A student trained on multi-agent traces also beats a single-agent student trained on 1.4x more tokens.
Why it matters: Self-improvement loops usually depend on an external verifier, so open-ended tasks with no checker are left out. MASS shows that one model can supply its own supervision signal by learning orchestration and bounded subagent execution from multi-agent trajectories.

Paper | Tweet

6. Sharpening Tax

A common hypothesis holds that RL post-training only sharpens behaviors the base model already has, raising single-shot accuracy at the cost of solution coverage. Researchers from Meta Superintelligence Labs test whether this holds for agentic tasks, where multi-turn tool use might need capabilities learned during post-training.

Base models as agents: Pre-trained LLMs with a light inference harness work as capable agents. Post-trained models win on pass@1, but at large K the base models often solve tasks their post-trained versions never solve on BFCL v4 multi-turn, ACEBench, and WebShop.
Why coverage drops: Post-training pushes each task toward always solved or never solved. Consistency and sampling efficiency increase, while coverage decreases.
Measuring the cost: The authors propose the Sharpening Tax, a metric for the test-time scalability lost after post-training. Across 42 base and post-trained cases from four model families and three benchmarks, the tax shows up in most settings, grows with model size, and can be estimated from a few rollouts.
Why it matters: Their fix, posterior-tempered group sampling (PTGS), sets the sampling temperature per prompt from its estimated difficulty during RL. It pays a smaller tax than a fixed-temperature baseline and also raises pass@1. If your agent relies on repeated sampling at test time, a base model may cover tasks that your post-trained model has lost.

Paper | Tweet

7. VERA

Long-horizon agents need environments that can be resumed at any stage and scored from observable evidence, yet most environments score only the final outcome. Researchers from NVIDIA present VERA, which builds such environments at scale and uses them to update both the model and its harness.

Verifiable environments from trajectories: VERA turns initial trajectories into more than 9,000 restartable sandboxes. An agent writes rubrics and executable checks, a judge verifies each sandbox, and only environments that run and can be scored from observable evidence enter the training bank.
Two update paths: VERA alternates between training the model with rubric rewards and editing the harness skills. A harness edit is kept only if it passes self-tests and adds at least 5 points on the development set, and a model checkpoint is rejected if its score drops by more than 20%.
Results: At 9B, the co-evolved agent beats the strongest single-axis baseline by 10.3 points on AutoCoWorkBench and 13.0 points on AutoMedBench. At 27B, it scores 71.6 on AutoCoWorkBench and 80.7 on AutoMedBench, transfers to unseen workflows, and keeps its general capabilities.
Why it matters: Training the harness alongside the model is a big part of owning the intelligence stack, and many frontier AI companies have started doing it. The open-source corpus of environments gives others a starting point for this kind of co-evolution on long-horizon work.

Paper | Tweet

8. Agent Plasticity

Researchers from Meta Superintelligence Labs introduce agent plasticity, a measure of how efficiently an agent converts experience into gains on held-out tasks per dollar spent on learning, with model weights frozen and each run starting from a fresh context while inheriting artifacts written by earlier runs. The model with the best final score is often a different model from the one that learns most efficiently. In chess, Go, and Hex, Claude Fable 5 reaches the highest final score, while GPT-5.6 Sol gains the most per dollar; in NetHack, only Claude Opus 5.5 improves significantly, by 66 normalized points for about $1,073 of learning. Slow learners often ignore artifacts they already wrote, while faster learners reuse their artifacts and still fail when an artifact is low quality.

Paper | Tweet

9. Continuous Memory Machines

Sakana AI’s Continuous Memory Machine gives a recurrent model two matrix-valued memories: a short-term store that tracks recent neuron activity and a long-term store for information needed later, with a Transformer reading and writing both at every step. Built on the Continuous Thought Machine, it beats LSTM, DNC, RMC, and CTM baselines on copy, associative recall, sorting, few-shot regression, and maze solving, and it generalizes to longer inputs than earlier memory-augmented networks. Its attention maps show it uses long-term memory for algorithmic and in-context tasks and skips it when a task does not need it.

Paper | Tweet

10. MIMESIS

Agent RL setups usually let an assistant LLM play the user, which makes the simulated user overly cooperative and explicit, and a fixed GPT-5.5 agent finds tau-bench tasks easier with these users than with real people. Researchers from Meta Superintelligence Labs train MIMESIS, a 9B user simulator built from human conversations with explicit reasoning supervision and 13 behavioral patterns observed in real users, which beats Claude Opus 5 on behavioral fidelity by 13.4 points. Agents trained against the frozen simulator with multi-turn RL outperform agents trained against GPT-5.5 under all nine unseen user simulators, and a coaching step that turns the simulator’s private reasoning into token-level feedback adds further gains.

Paper | Tweet

🤖 AI Agents Weekly: Claude Haiku 5.5, Gemini Agent, Mistral Large 4, Decisions API, Personal Agent Protocol, Devin Dreaming, and More

Sat, 10 Oct 2026 14:40:28 GMT

In today’s issue:

Anthropic ships Claude Haiku 5.5
Google launches the Gemini agent
Mistral previews Large 4
OpenAI opens the Decisions API
Meta and Sierra propose Personal Agent Protocol
Devin gets Memory and Dreaming
Reflection unveils Beam open model
GPT-6 brings Intelligent UI to ChatGPT
Hugging Face trains models across harnesses
OpenAI releases 719 math manuscripts

And all the top AI dev news, papers, and tools.

🥇Top AI Papers of the Week

Sun, 04 Oct 2026 15:37:31 GMT

1. Context Language Models

Agent harnesses usually manage the model’s context through fixed rules such as summarization or compaction. Researchers at Meta and collaborators propose Context Language Models (CLMs), which treat the live context as a file the model can edit freely, deciding what to keep, rewrite, or remove.

Context as a read-write file: The model edits its own context with code, writing loops that prune irrelevant results, defining functions it reuses, and tracking subagents. Recursive language models place a large input in an external variable the model can read, but they do not let it edit its live interaction context. Because several agent contexts can coexist as files, the approach extends to multi-agent systems.
Works zero-shot: Built from existing models with no training, CLMs reach 11.4% higher accuracy with 21.5% fewer FLOPs on BrowseComp-Plus than state-of-the-art context-management strategies, 5% higher scores with 59% fewer FLOPs on the 12-hour EdgeBench, and 65% more improvement for the same compute on a 24-hour agent-swarm task across six repositories.
Learnable in context and in weights: Natural-language instructions evolved through a skill-optimization loop raise held-out accuracy by up to 35.9 points on a context-management task. An online RL method improves Qwen3.5-9B on BrowseComp-Plus by 47.6% while using 12% fewer FLOPs.
Why it matters: Edits in the middle of the context break prefix caching, so the authors co-design Suffix Cache Reuse, which cuts server-side compute by 35% against standard SGLang at matched performance. Context management can move from the harness into the model without raising serving cost.

Paper | Tweet

2. JAZ

Long-term memory and self-improvement are usually built as separate systems around the agent loop. Researchers from MIT CSAIL built JAZ to test how far a minimal harness, little more than the agent loop itself, can go on the tasks those systems target.

One primitive: JAZ exposes a single LLM-based primitive, invoke, which acts as a function whose implementation the LLM writes at runtime each time it is called. Built-in hooks let the programmer apply constraints and monitor the run.
Everything is a variable: The LLM can write arbitrary executable code, including recursive calls to invoke, so subagents are the default. All inputs to invoke and the full interaction history live as variables in the code environment, where the model can read and transform them with code.
Beats specialized systems: With prompting only and no manually designed tools, memory system, or file system, JAZ outperforms Letta (MemGPT) by 8% at half its cost on the recall-heavy portion of StuLife, a long-horizon benchmark that requires recall far beyond the context window. On AppWorld, it beats ACE, a continual self-improvement method, by 4% at lower cost.
Why it matters: Memory and self-improvement become code the agent writes inside its own loop. If you build custom harnesses, this is evidence that a smaller surface can match heavier infrastructure on these workloads.

Paper | Tweet

3. Agensh

Multi-agent harnesses usually depend on a central orchestrator that assigns tasks and coordinates workers, and that orchestrator limits how many agents the system can use. Microsoft Research introduces Agensh, a self-organized multi-agent harness with no central orchestrator, and scales it to 1,024 coding agents.

A shared cooperation loop: Every worker runs the same loop asynchronously. It gathers context, claims and self-assigns a sub-task, takes action and shares findings, verifies the result, and merges progress.
Organization infrastructure: Three components support the loop. A shared workspace holds proposed, ongoing, and completed work, a message interface lets workers communicate, and a shared context retains reusable findings and work intentions.
Scaling the number of agents: On the five hardest ProgramBench tasks with GPT-5.6-sol, going from 1 to 128 agents raises the mean final test-pass rate from 19.31% to 28.78%, about a 49% relative improvement, and larger teams reach a given pass rate sooner. On building pandoc from scratch under a 6-hour budget, going from 1 to 1,024 agents raises the test-pass rate from 33.89% to 55.06%.
Why it matters: Worker trajectories show forms of cooperation that the agents start on their own and that become standard practice as the organization grows. The authors treat the number of agents as a new scaling dimension, which is most useful for complex tasks under hard latency limits or time budgets.

Paper | Tweet

4. AutoGym

Training agents with RL requires a gym, meaning a task, an executable environment to attempt it in, and a verifier that reliably separates success from failure. These gyms are still built by hand, saturate as models improve, and get exposed to contamination. Researchers from Amazon AGI present AutoGym, which generates complete gyms from a minimal domain seed or from prior model trajectories.

Blueprint first: AutoGym specifies the valid solution space, environment requirements, and verification criteria before it builds the environment. Solvability is settled during construction, so no unreliable LLM judge has to decide correctness afterward.
Difficulty you can steer: Explicit generation parameters control task topology, interaction depth, capability axes, question obfuscation, and distractor composition. Single-pass synthetic tasks tend to be hard only in their phrasing, and these parameters target actual difficulty.
Active curriculum: Performance-informed calibration shifts the distribution over those parameters as model capabilities change, and failure analysis feeds recurring capability gaps back into the generation parameters.
Why it matters: Across productivity and temporal-reasoning settings, AutoGym produces gyms spanning the capability spectrum, including instances that challenge frontier models. Building RL environments is becoming a core AI engineering skill, and this gives a recipe for gyms that keep pace with the models trained on them.

Paper | Tweet

Message from the Editor

Our new DAIR Academy lab, Build a Website with a Pi Coding Agent, teaches you to build and refine a responsive one-page website by directing a Pi coding agent. Across 5 labs, you add a practical feature to the same project each time, from the first hero section to responsive styling, an interaction, accessibility, and final polish.

Get Started with Pi

5. CASD

Search-based prompt optimizers such as GEPA propose edits, run fresh rollouts, score them, and keep only the edits that improve a validation metric. Researchers from Microsoft show that this loop may be unnecessary when you already have a corpus of agent trajectories.

One pass over the logs: Coding-Agent Skill Distillation (CASD) gives an off-the-shelf coding agent a static corpus of trajectories. The agent writes and runs analysis code to compute corpus-wide statistics, find systematic failure modes, inspect representative episodes, and distill the findings into behavioral rules in one prompt. It needs no environment access and no validation data.
Reflection scope: Search-based optimizers reflect on small batches of trajectories at each step, so failures that only show up across the whole corpus stay invisible to them. CASD reads the whole corpus, so it can find those failures.
Better and cheaper: Across ALFWorld, tau2-bench retail and telecom, and SpreadsheetBench-Verified, a single CASD pass improves the unoptimized baseline by 16.6 points on average, against 10.9 for GEPA and 5.3 for SkillOpt. Each optimized prompt costs about $1.60, over 22x cheaper than validation-gated search.
Why it matters: Even when GEPA and SkillOpt also get validation data and unrestricted environment access, CASD stays ahead on two of four benchmarks. If your agents already produce logs, pointing a coding agent at them is a cheap first step before running a search-based optimizer.

Paper | Tweet

6. Taste-Bench

On long-horizon tasks, decisions such as which hypothesis to test or which implementation to build on determine how the whole run turns out. Researchers at Microsoft and collaborators call the ability to make these decisions well an agent’s taste, and they built Taste-Bench to measure it.

Decision forks: Each question shows a point in a trajectory where several directions are open, and one leads to a better outcome. The model picks a direction without seeing what happens after the fork.
Mined automatically: Forks come from engineering and research runs, either from parallel attempts at the same task or from detours inside a single trajectory. Filters drop forks that are guessable from the options alone and forks that cannot be decided from the context, so no human annotation is needed.
Just under 60%: The best model answers 59.7% of questions correctly. Forks whose deciding evidence appears later in the trajectory are much harder for every model, and a larger reasoning budget does not improve accuracy.
Why it matters: Taste can be trained. The authors distill the judgment of a teacher that has seen the outcome into a student model, which makes better decisions on unseen tasks and improves end-to-end success on held-out SWE-bench Pro tasks. Benchmarks that score only end-to-end success miss this capability, and for recursive self-improvement, an agent’s choice of direction also matters.

Paper | Tweet

7. Jev-Mem

Many agentic memory systems use an autoregressive LLM to decide how memories are organized, retrieved, and used, which puts expensive generation on the critical path of every memory operation. Jev-Mem borrows its design from System-One/System-Two cognition and hands those decisions to a lightweight controller.

Three planes: A System-One control plane makes the fast decisions, a structured multi-relational memory plane stores semantic, temporal, causal, and entity relations, and a System-Two reasoning plane handles slower, deliberative reasoning.
The controller runs memory: When storing, the controller assigns memory types and relations. When reading, it handles query routing, retrieval-budget allocation, graph traversal, candidate scoring, and adaptive stopping. The LLM is called only for complex reasoning and writing the final answer.
Faster and more accurate: On LoCoMo, Jev-Mem scores 0.777 overall with an LLM judge, an 11.0% relative improvement over the strongest baseline. Memory construction takes 158 seconds, 6.6x faster than the fastest competing memory system, and average query latency drops 36.7% to 0.93 seconds.
Why it matters: Memory latency adds up across every step of a long-horizon agent. Moving routine memory decisions to a small controller lowers that cost while improving answer quality, and the same split could apply to other harness decisions that a frontier model currently makes.

Paper | Tweet

8. Critical-State RL

Salesforce AI Research’s Critical-State RL finds the one call in a multi-turn tool-use interaction where training helps, since reward variation that depends on later turns often reflects downstream randomness instead of the current action. It uses nested sampling to separate action-dependent reward variation from continuation noise, then trains only the selected call with contextual-bandit updates. On BFCL v4 missing-function tasks, training the selected turn adds about 14 points, while training the alternative turn leaves accuracy flat or worse.

Paper | Tweet

9. SkillGym

SkillGym turns human-written agent skills into 2,756 verifiable training environments across 12 categories, each with code-based checkers, and collects 8,364 successful trajectories for fine-tuning. Under Claude Code, fine-tuning Qwen3.5-35B-A3B adds 19.10 points on Terminal-Bench 2.1 and 28.13 points on skill-assisted SkillsBench v1.1, reaching 51.47%, above the reported scores for Claude Sonnet 4.6 and GPT-5.4 Mini. With no skills loaded, the trained model still beats the base model with skills in context.

Paper | Tweet

10. AutoCompact

AutoCompact trains a coding agent to decide when to compact its context, what working state to keep, and how to continue afterward, as part of its own policy. A judge reviews the base agent’s compaction decisions and replaces flawed ones before they execute, and the corrected trajectories are used for SFT and then for RL that optimizes coding and compaction together on task success. Pass rates rise by 9.2 points on SWE-bench Verified and 5.0 points on SWE-PolyBench Verified, and the gains hold with both a 256K window that never overflows and a 16K window that falls back to forced compaction.

Paper | Tweet

🤖 AI Agents Weekly: Gemini 4 Argon, OpenAI Dots, GPT-6.1 Sol, Claude Sonnet 5.5, Pi 1.0, Claude Code Mods, and More

Sat, 03 Oct 2026 14:48:39 GMT

In today’s issue:

Google unveils Gemini 4 Argon
OpenAI launches always-on dots
OpenAI ships GPT-6.1 Sol
Anthropic launches Claude Sonnet 5.5
Earendil ships Pi 1.0 and Pi Durable
Claude Code adds mods
DeepSeek open-sources its agent harness
Manus 2.0 runs on Cascade
Schema hits 99.2% on ARC-AGI-3
OpenAI refreshes the Codex CLI

And all the top AI dev news, papers, and tools.

🥇Top AI Papers of the Week

Sun, 27 Sep 2026 17:15:43 GMT

1. HySparse2

In agent workloads, a short tool call can return a long search result or execution trace that has to be prefilled before decoding resumes, and the context keeps growing across turns. Xiaomi’s MiMo team built HySparse2, the attention architecture behind the upcoming MiMo-V3, to lower prefill cost and KV-cache size while improving long-context retrieval.

Two levels of KV sharing: Following YOCO, the model is split into a self-decoder and a cross-decoder. KV Bridging builds the cross-decoder’s full-attention KV caches from the hidden states of the self-decoder’s full-attention layers, and KV Reuse lets each sparse layer reuse the KV cache and selection indices of the full-attention layer before it.
Prefill exits early: Because every cross-decoder KV cache comes from the self-decoder, prefill can stop once the self-decoder finishes. Token-level selection replaces block-level selection, and a forced window of recent tokens replaces the separate sliding-window branch, so local and global tokens share one cache.
Cheaper at 1M tokens: On 80B-A3B MoE models trained on the same data, HySparse2 cuts prefill FLOPs by 5.02x against the Hybrid SWA design used in the MiMo-V2 series and by 2.92x against HySparse. Its KV cache takes 2.69 GB, against 12.09 GB for Hybrid SWA.
Why it matters: After light post-training, HySparse2 scores 11.30 points higher than HySparse on MRCR-v2 and 19.81 points higher on RULER-v2, with lower AgentPPL and LongPPL than both baselines up to 256k tokens. For long-running agents that prefill and store a long observation every turn, it lowers both costs and improves retrieval accuracy.

Paper

Message from our Sponsor

Step 5 Preview is StepFun’s new flagship model for agentic work, a 600B-total, 27B-active MoE with a 1M-token context and vision input. Open weights are scheduled for October 15.

I tested it early as a coding agent, in a minimal harness against GLM 5.3 on two real tasks in the same repo. Both models solved both tasks with no regressions. Step 5 Preview checked its work and declared itself done both times, while GLM 5.3 kept going until the step limit ended the run. In a separate long-context test, it found all five clues hidden in about 368K tokens of incident tickets and connected them to the root cause in about 90 seconds.

It sits on the Pareto frontier for cost against capability, so it is worth trying in your coding agent.

Try Step 5 Preview

2. SIFT

Coding agents that rewrite their own implementation can improve on benchmarks, but prior methods such as the Darwin Gödel Machine (DGM) are expensive to run. Researchers from MIT and Sakana AI trace most of that cost to one step and make it cheaper.

Evaluation is the bottleneck: Earlier approaches score every candidate self-modification by re-running benchmark tasks with the modified agent. That evaluation dominates runtime, so SIFT adds a cheaper signal beforehand.
Judge first, benchmark later: An LLM judge compares candidate patches pairwise, a regularized Bradley-Terry model turns the win-loss record into strength scores, and those scores drive parent sampling in a disaggregated tree search. Full benchmark runs are reserved for the most promising nodes.
A tenth of the compute: With o3-mini, SIFT reaches 35.1% on Polyglot after 30 expansions, against 30.7% for DGM after 80 nodes, in under 50 CPU hours and under 5 hours of wall clock. The Qwen3-30B configuration runs its full search at 224 CPU hours and $34 of API spend, about a tenth of the DGM baseline.
Why it matters: Judge quality decides the outcome. On TerminalBench, gpt-5.4-high as the judge finds a 36.7% agent from a 29.2% start, while gpt-5 finds 34.5% and ranks a weaker candidate first. If you run self-improvement loops, the judge deserves as much attention as the search.

Paper | Tweet

3. GAVEL

LLM plans for long-horizon robot tasks often break embodiment constraints, fail to recover from mistakes, or lose track of objects they cannot see. GAVEL adds an explicit graph world model around the LLM and more than doubles the success rate of a small model without changing its weights.

A graph that tracks the world: The graph holds object relations, action preconditions and effects, and probabilistic beliefs about where unobserved objects are. Before the robot executes an LLM-generated action, the graph predicts what the action would do.
Repair without calling the model: It catches violations before execution. When the fix follows directly from the world model, GAVEL repairs it on its own, and only errors that need semantic reasoning go back to the LLM for replanning.
Large gains on BEHAVIOR-1K: With Qwen3-8B, single-task success rises from 41.2% to 91.8% across 100 long-horizon tasks, and multi-task success rises from 19.9% to 92.6% across 500 instructions. Reasoning over the distribution of possible object locations also reorders subtasks and cuts travel distance by about 5.4%.
Why it matters: Many long-horizon agent failures come from losing track of state rather than from weak reasoning. A symbolic model outside the LLM catches those failures cheaply, and the same idea applies to software agents that need to track the state of files, tickets, or accounts.

Paper | Tweet

4. WFM

More agents now store long-term memory as an LLM Wiki, a folder of markdown pages linked to each other. Each page holds dense text, and the links provide structure; WFM is a Wiki Foundation Model trained to use both when retrieving.

Wiki as a graph: WFM formalizes a Wiki Graph schema in which entity relations and passage nodes live in one graph. The explicit links stay intact while each page keeps its full text, which is harder to capture with sparse graph embeddings.
Query-conditioned retrieval: Retrieval runs message passing over the graph, conditioned on the query, with attentive aggregation and a regularizer on attention variance. Page text and link structure shape the result together.
Faster distributed training: The team built a GPU-to-GPU exchange protocol over NCCL that avoids CPU serialization and memory copies when the graph is split across GPUs. Training runs 10.5x faster on distributed clusters, targeting the overhead that makes graph encoders hard to deploy at scale.
Why it matters: WFM reports strong results on five long-term agent memory and multi-hop reasoning benchmarks. If your agent’s memory is already a folder of linked markdown files, this retrieval model is designed for that format instead of one adapted from plain RAG or sparse knowledge graphs.

Paper | Tweet

5. JEV-as-a-Judge

Running a frontier LLM as the judge on every eval gets expensive at scale. This paper tests a cheaper setup: a decision-only judge handles most calls, and only uncertain ones go to a frontier model.

A judge with no reasoning text: JEV, TypeSafe AI’s decision-only model, returns a verdict and label probabilities. It costs $0.044 per 1,000 judgments at a median latency of 0.152 seconds, against $12.182 and 1.885 seconds for GPT-6, about 277 times cheaper.
Close on ordinary judgments: Compared with sixteen generative and reward-model judges under blinded human adjudication, JEV stays within 3 points of GPT-6 on preference and evidence-grounded factuality, with 92.2% against 93.5% on RewardBench and 87.5% against 86.7% on HaluEval.
Weaker on hard checks: The gap grows to 9 to 20 points when a judgment requires checking a derivation or rejecting an elaborately written wrong answer, such as 78.6% against 93.1% on JudgeBench. On several benchmarks, those errors cluster in JEV’s low-confidence decisions.
Why it matters: Because the errors cluster there, a cascade that accepts confident verdicts and escalates the rest to GPT-6 Astra kept 99% of GPT-6’s accuracy at about 57% of its fee on 510 held-out preference pairs. The escalation threshold did not transfer across every fallback model, so the authors recommend setting it on your own data.

Paper | Tweet

6. Harness-Zero

A specialized harness can raise an agent’s performance a lot, but the best harness differs across domains, instances, and models. Harness-Zero, from Google and colleagues, uses the specialized harness only during training and moves the behavior it induces into the model weights.

Harness distillation: The goal is to keep the gains of a domain-optimized harness while deploying under a single fixed harness. The two harnesses have different action spaces and information, so the optimized one cannot supervise the target one directly.
Agent-as-harness: A harnessing agent guided by the optimized harness corrects the student’s responses in the deployment harness’s action space before they run. Those corrected runs become the fine-tuning demonstrations.
Better without the harness than with it: With the specialized harness removed at deployment, macro-average task success goes from 23.3% to 44.3%, above the 41.7% the base model reaches with that harness still attached. Across 28 harness-induced behaviors in knowledge work, tool use, and science, the model recovers 82.3% on average.
Why it matters: Teams that maintain a separate harness per domain carry routing and maintenance costs that grow with every new domain. This work suggests training some of that harness logic into one model instead. For frontier models using the same evolved harness, the agent-as-harness form also beat the code-as-harness form.

Paper | Tweet

7. Self-Organizing Agent Teams

Multi-agent systems usually fix roles and protocols in advance. Researchers from Stanford and Together AI let a fixed team of models learn how to organize its own collaboration from past exchanges.

The team rewrites its own strategy: One member reviews earlier exchanges and outcomes, then rewrites the teamwork strategy, covering roles, the order of discussion phases, who participates, and how partial answers are combined. Strategies are learned offline and frozen before evaluation.
Learned from 15 problems: The math and physics team (o3-mini, Claude Sonnet 4, and DeepSeek-V3) learned its strategies from only 15 AIME 2024 problems, then applied them unchanged to held-out problems and four new benchmarks.
Beats a perfect router: Across five benchmarks, the team averaged 66.7%, against 48.8% for its strongest member, 58.7% for compute-matched inference by that member, and 59.0% for a perfect router over the members’ independent answers. On AIME 2026, it beat that router by 13.4 points, so the team produced correct solutions that no member reached alone.
Why it matters: Gains varied across benchmarks, and the authors found they track demonstrability, whether a team can recognize correct reasoning once it appears (Spearman 0.90 across eight benchmarks). That gives a practical test for when a multi-agent setup is worth running.

Paper | Tweet

8. ScientistTwo

Google Cloud AI Research built ScientistTwo, a multi-agent framework that takes a problem from a human expert and runs the full discovery cycle without further intervention, from establishing baselines and screening ideas on a data subset to running its own ablations and revising the idea from them. Manuscript drafting includes a simulated peer-review and rebuttal engine. Benchmarked on problems from papers accepted at ICLR, ICML, and NeurIPS, its solutions outperform the human state-of-the-art models, and its papers score higher average ratings than the human-authored ones under automated AI reviewers.

Paper | Tweet

9. XYEval

Users often suggest a fix that sounds right and is wrong, and Google DeepMind’s XYEval measures how often agents go along with it by adding one confident, misleading hint to tasks from tau2-bench, SWE-bench, Terminal-Bench, HLE, and MCP-Atlas while keeping the correct solution unchanged. Scores drop by up to 46.7% relative across Gemini, Claude Opus 4.8, and GPT 5.5, and agents often disagree with the hint in their reasoning, then follow it without telling the user. A system prompt warning about the XY problem helps on single-turn tasks but leaves large drops on multi-turn ones such as tau2-bench and SWE-bench Verified.

Paper | Tweet

10. EvoOntology

EvoOntology replaces the hand-written semantic layer that data agents usually get in their prompt with an ontology they query at runtime, built by a dedicated builder agent and served over MCP with schema, content, and tool layers. The ontology evolves through small typed edits, and we keep each edit only if a paired evaluation on the same backbone shows it helps. On DDR-Bench, accuracy rises 17.8 points on average across backbones, and on BIRD, execution accuracy rises 7.4 points, with tool-layer edits accounting for 57% of the gain from evolution.

Paper | Tweet

🤖 AI Agents Weekly: Claude Opus 5.5, GPT-6 Sol and Luna, MiMo-V2.6, Step 5 Preview, Google AX, Agensh, and More

Sat, 26 Sep 2026 14:55:56 GMT

In today’s issue:

Anthropic ships Claude Opus 5.5
OpenAI launches GPT-6 Sol and Luna
Xiaomi open-sources MiMo-V2.6
StepFun previews Step 5
Claude agents find a new enzyme
Google open-sources AX
Prime Intellect launches Sandboxes
Agensh scales to 1,024 agents
xAI releases Grok 4.7
Research agent rewrites its own code

And all the top AI dev news, papers, and tools.

🥇Top AI Papers of the Week

Sun, 20 Sep 2026 17:20:29 GMT

1. Byte Model Scaling

Byte-level language models drop the tokenizer and read raw bytes, which removes a preprocessing step that no one likes but also costs accuracy at small scale. Meta studies what happens as compute grows, distilling 1B byte students from token teachers on up to 1 trillion bytes, and the ordering flips.

Two ways to convert a teacher: Distilling a byte student from a token teacher requires turning token logits into byte logits. The paper gives an approximate method, Marginalize-It, and an exact one, End-Of-Token, which preserves the distribution by accounting for the tokenization paths that marginalization alone misses.
Token models plateau, byte models keep climbing: Token models lead at low compute and then flatten out. The byte models start behind, pass the token models as compute grows, and the fitted scaling laws put the End-Of-Token student up to 4% ahead of the distilled token model at the asymptote.
Better data efficiency: The byte models match the distilled token model using one-sixth of the training data, and a 256-entry vocabulary cuts teacher-logit storage to about a fifth, which makes distillation runs cheaper to store and replay.
Why it matters: The usual reason to keep tokenizers is that byte models underperform at the scales most teams train at. This work shows that the gap closes and reverses with compute, so byte-level pretraining is worth revisiting for anyone planning a small model with a long training budget.

Paper | Tweet

2. SoL-Pi

Agent harnesses are tuned by hand, one mechanism at a time, against whatever environment the team happens to have. NVIDIA moves that tuning into an automated research loop and keeps only the mechanisms that survive selection across many environments.

Auto-research at the harness layer: The loop runs across repository-derived and verifier-driven environments rather than a single benchmark, proposing harness mechanisms, testing them, and discarding the ones that fail to hold up. Code is on GitHub under NVlabs.
Four mechanisms survived: Action Fusion changes how actions execute, Online Context Compact handles compaction during a run, ObservationPack reshapes observation handling, and Evidence-Preserving Reducer covers delegated reading.
Half the token traffic: SoL-Pi cuts token traffic by nearly half while matching its baseline harness on GPT-5.6 Sol and Opus 5, so the savings do not come out of task performance.
Why it matters: On the 51-task EdgeBench evaluation, the savings work out to about a third off API cost, an estimated $8.75 to $13.50 per hour against the native Codex and Claude Code harnesses and $4.36 to $5.71 against the baseline harness. Because the search ran across many environments, the retained mechanisms keep working outside the setting that produced them, which is the usual failure mode of hand-tuned harness tweaks.

Paper | Tweet

3. Stellar Colosseum

Long mathematical proofs break the usual agent loop, since a single wrong step early on invalidates everything after it. Google Research built a many-agent harness for this setting, and it produced new results on open problems from FOCS and JMLR papers.

Staged, with a gate in the middle: The harness explores several proof strategies first, then waits for a readiness gate before committing to one route and breaking it into section-level subproblems. Nothing gets decomposed until a route looks like it supports a full proof plan.
Generate, attack, merge: Inside each stage, candidates are produced in parallel, attacked with targeted falsification, and merged along with their critiques, so a surviving candidate carries the objections raised against it into the next stage.
Feedback routed to the right section: Each verifier finding is sent back to the section it affects rather than to the whole proof, which keeps revision local and avoids regenerating work that already passed verification.
Why it matters: With Gemini 3.1 Pro and Gemini 3.7 Flash, the harness reaches 71.0% on TCS-Bench, a set of research-level theorem-proving tasks drawn from FOCS, STOC, and SODA papers, and with execution feedback it solves 218 of 222 Codeforces problems. The staged design transfers to any domain where a partial result has to be verified before the next step is worth taking.

Paper | Tweet

4. GAUGE

The standard way to compare task agents is to have an LLM user simulator talk to each one and an LLM judge score the transcript. Amazon audits that gate against verifiable rewards across 25 agents from six providers, and finds two specific failures.

Satisfaction does not track success: 57.5% of the conversations raters marked as satisfied had failed the customer’s task. A pleasant transcript and a completed task are different things, and the judge measures the first one.
Close calls go wrong: The ranking holds up across agents of very different ability. Among near-equal agents, the gate picks the lower-reward one on 31% of pairs, against under 1% for pairs that are far apart, so the gate fails precisely where teams use it to choose between two candidate agents.
Judges favor their own family: Across tau2-bench and SimulatorArena, judges scored agents from their own model family higher, which adds a second source of bias on top of the satisfaction gap.
Why it matters: The recommended fix is cheap. A judge-free completion bit catches truncation regressions on its own, and the judge is trusted only after it has been calibrated against a verifiable reward. If you are running an LLM judge over simulated conversations to pick between agent versions, this gives you a concrete calibration step before the scores decide anything.

Paper | Tweet

Message from the Editor

Our new DAIR Academy lab, Write better with Claude Fable 5.1, shows how to get clearer prose out of the model. Across 3 labs, you add the instruction Anthropic recommends, measure the difference with a small script, and build a reusable style file. Free for a limited time.

Get Started

5. Capability Laundering

Safety evaluations usually ask whether a model refuses a harmful request. Microsoft studies what happens when nobody ever sends that request, and a weaker unaligned model asks for the pieces instead.

The attack in one line: A local unaligned model splits a harmful objective into harmless-looking subquestions, asks an aligned frontier model each one in a separate session, and recombines the answers locally. The authors call this capability laundering.
Why every request passes: No single answer from the frontier model is a harmful task, so each request clears the policy on its own merits. The harm comes from composing the fragments, and that step happens outside the aligned model entirely, where no policy is watching.
Measured uplift: With GPT-5.5, Claude Opus 4.8, and Grok-4.3 as the consulted models, Gemma-4-31B recovered 8 of 14 CyBench tasks it had failed alone when it consulted GPT-5.5. On a CBRN attack chain, consultation raised its mean rubric score from 62.3 to 83.1.
Why it matters: This is an argument for evaluating at the session-history and account level rather than per request. A safety layer that scores each prompt independently has no way to see a decomposition spread across separate sessions, and the uplift numbers show the aggregate is worth defending against.

Paper | Tweet

6. Bash vs Typed Tools

Deciding which tools to hand an enterprise agent usually means writing typed tool definitions for every system it touches. Microsoft compared five tool interfaces head to head, and the plainest option won.

Five interfaces, two benchmarks: The study covers a catalog of typed tools, bash alone, combinations of the two, and programmatic tool calling where the agent writes code against a fixed catalog. It runs on TheAgentCompany and APEX-Agents with Opus-4.8 and GPT-5.5.
Bash wins on both quality and cost: Bash alone scored 21.8 to 24.5 points higher than typed tools on TheAgentCompany and 4.8 to 7.4 points higher on APEX-Agents, while using 19% to 72% fewer tokens.
Adding tools on top does not help: Layering typed tools or agent-written tools on top of bash gave no measurable gain, so the extra definitions cost engineering time without buying accuracy.
Why it matters: The authors recommend bash whenever execution can be sandboxed, and programmatic tool calling when compliance requires a fixed tool list. For teams that have been writing one typed tool per integration, this suggests spending that effort on the sandbox instead.

Paper | Tweet

7. Salesforce Koa

Custom enterprise models usually need a training set someone has to build. Salesforce trained Koa from artifacts it already had, namely the declarative files that configure its agents.

Configuration files become environments: Salesforce takes Agent Script specifications, the declarative files that define Agentforce agents, and expands them into multi-turn tasks with simulated user personas. The specs describe what an agent is supposed to do, which is most of what an RL environment needs.
Reward tied to resolution: The reward checks whether the agent resolved the task with the right tool calls rather than whether the transcript reads well, and training uses GRPO. Koa starts from the open-weight Nemotron-3-Super-120B.
Modest and consistent gains: Koa scores 69.41 on Tau2Bench against 68.64 for its base and 54.48 for GPT-4.1. On CRM Bench, it reaches 0.86, close to Claude Opus 4.8 at 0.87, and function-call accuracy rises from 0.71 to 0.77.
Why it matters: What transfers here is where the training data came from. If your company already describes its workflows in a structured format, whether that is agent configs, runbooks, or API specs, those descriptions can be turned into RL environments without a separate data collection project.

Paper | Tweet

8. Model Pool Selection

NVIDIA compared eight strategies for choosing which models go into a multi-agent system, based on size, accuracy, answer diversity, and error diversity, across routing, majority vote, and LLM-as-judge setups on hard science benchmarks. Larger pools of different open models raised the theoretical best-case accuracy, while achieved accuracy often fell below the single best model in the pool, and using several copies of one model worked better. Majority vote over the best single model raised HLE accuracy from 29.4% to 32.2%, so measure what another model adds before putting it in the router.

Paper | Tweet

9. Fuse

People ask assistants for social advice constantly, and the assistant only hears the user’s version of events, which makes it hard to check whether it read the situation correctly. Google Research builds that ground truth by simulation, with a target agent holding a hidden motive while a user agent relays events to the assistant, which then has to infer the motive. Across 24k human annotations validating the simulations and 12 LLMs tested, biased framing from the user shifted the assistant’s answer, and longer conversations with room for clarifying questions did not reliably help.

Paper | Tweet

10. Skill-Based Agentic Evaluation

Storing a fixed reference answer for every eval case breaks when the underlying data changes daily, so Adobe researchers write each reference answer as a Python function that runs against the live system at evaluation time. An LLM judge then splits the agent’s response and the computed answer into atomic facts and scores precision and recall regardless of output format, raising agreement with expert labels from an MCC of 0.331 to 0.427 while cutting token cost per case by 16%. A judge given no ground truth scored an MCC of -0.379, which is worse than chance.

Paper | Tweet

🤖 AI Agents Weekly: Jev, Salesforce Koa, Claude Code Projects, Anthropic R&D Metrics, Periodic Neon, Gemini 3.8 Live, and More

Sat, 19 Sep 2026 17:27:24 GMT

In today’s issue:

TypeSafe launches Jev
Salesforce releases Koa
Claude Code ships Projects
Anthropic publishes AI R&D metrics
Periodic Labs releases Neon
Gemini 3.8 Live launches
Devin adds codebase-wide Code Scans
HarnessTax measures the harness cost
Claude Code reads AGENTS.md
Cowork merges into Claude

And all the top AI dev news, papers, and tools.

🥇Top AI Papers of the Week

Sun, 13 Sep 2026 15:54:16 GMT

1. Procedural Graphs

Long-horizon agents usually pick each action by generating over a growing history, which leaves the procedural knowledge of what to do next, in what order, and under which conditions implicit. As trajectories get longer they lose track of objectives, call tools out of order, and repeat actions that already failed. Researchers at Google make that knowledge an explicit graph the agent can query.

Procedures instead of facts: A knowledge graph stores entity-relation-entity triplets to answer what-is questions. A Procedural Graph stores procedure-relation-procedure triplets, so the agent can ask what to do next and under which conditions.
Guidance without dictation: At each step the framework localizes the agent’s active node and extracts the surrounding subgraph, and a guidance model turns it into step-level guidance that biases the solver’s next action without dictating it.
The graph edits itself: An LLM refiner contrasts failed trajectories with successful ones and edits the graph’s topology and attributes. Edits are committed only when held-out validation performance holds or improves, and rejected edits stay on file so the same change is not proposed twice.
Why it matters: Starting from a minimal skeleton, the loop builds graphs that match or beat hand-designed ones, and it can repair a flawed expert prior instead of inheriting it. Across datasets, task types, and LLMs, it delivers consistent gains over memory-based baselines, which gives teams whose agents drift on long tasks a structure they can inspect and improve without manual engineering.

Paper | Tweet

2. FrogNano

Small coding agents are usually built by distilling a frontier model’s trajectories. Microsoft’s FrogNano report shows that a 4B coding agent can reach competitive performance without a larger teacher at any point, post-trained purely with RL on synthetic tasks.

Built for minimal hardware: The target is a coding agent that runs on minimal machines, which rules out both a frontier backbone and a frontier teacher. The agent starts from Qwen3.5-4B and is post-trained on roughly 1,500 software engineering environments.
Tasks at the edge of learnability: An online task synthesis pipeline called TaskPilot generates executable tasks from real repository snapshots and calibrates them to the current checkpoint, so the agent keeps training on problems it can just barely solve. Tasks that are too easy or too hard are filtered out before each RL round.
Calibration over volume: The report credits calibration, rather than the amount of synthetic data, as the main ingredient. Training runs as repeated rounds of task synthesis and RL inside Leaf, a lightweight harness with five typed tools.
Why it matters: If synthetic tasks alone can train a competitive 4B coding agent, teams can build small agents for local and resource-constrained deployments without access to a frontier teacher. The task generator, more than the dataset size, looks like the component worth investing in.

Paper | Tweet

3. STAIR

Retrievers chunk long documents by length, which throws away the hierarchy the document already has. Researchers at IBM point out that a table of contents already encodes that global structure, and they build a retriever around it.

Addressing by table of contents: STAIR is a generative retriever, meaning the LLM stores and retrieves information from its own parameters. It addresses that information through the corpus’s table of contents, so retrieval follows a structure the corpus supplies rather than one invented for the index.
A new benchmark: The authors release SearchTome, built from 18 books across 6 domains, to support further research on retrieval that uses the table of contents.
Strong recall against baselines: STAIR reaches Recall@1 of 82.6% on SearchTome against 76.9% for a fine-tuned Differentiable Search Index, a statistically significant gap. BM25 lands at 59.5%, DPR at 68.7%, and out-of-the-box Mistral at 13.8%.
Why it matters: Hallucinated results are the standing objection to generative retrieval, and STAIR keeps the hallucination rate below 0.05% while generalizing to sections with very few training examples. For corpora with real structure, such as manuals, textbooks, and long reports, the hierarchy is a signal that length-based chunking throws away.

Paper | Tweet

4. AI-Native Design Docs

Google DeepMind, MIT, and colleagues maintain a performance-modeling library called SMART whose main branch contains almost no code. The repository is a directed graph of natural-language design docs, and coding sub-agents regenerate the entire implementation from those docs whenever a version updates.

Every human change is a doc edit: Engineers do not patch the code directly. They edit a design doc in natural language, so the library documents itself by construction.
Why regenerate at all: ML performance modeling invalidates its own abstractions with every new generation of hardware and models. The authors argue that coding agents are now fast and cheap enough that regenerating a library costs less than paying down the tech debt of patching it.
Two ingredients keep regeneration reliable: The design docs are written around step-by-step worked examples that act as in-context demonstrations for the generating agents. The system is also anchored on a minimal, recursively defined operator IR with symbolic cost expressions in SymPy, with a fast analytical mode for large sweeps and a slower modulo-scheduling mode for fine-grained schedule studies.
Why it matters: Regenerated implementations reproduce hand-audited reference models to round-off precision, including DeepSeek-V3 serving on a TPU pod slice. That result supports keeping design docs as the durable artifact in fast-moving domains and regenerating the code as a build product.

Paper | Tweet

Message from the Editor

We are excited to release our first paper collection on Harness Engineering. It’s a great place to find out the latest seminal papers in harness engineering and AI agents.

Go to Series

5. PARSER

Sequential memory agents read long documents one chunk at a time while carrying a compact memory state. That design ties reasoning depth to how far the agent has read, makes accuracy sensitive to where the evidence sits, and grows latency linearly with document length. PARSER separates reading from reasoning.

Parallel reading: A bank of lightweight subagents, each bound to a single chunk, reads the entire document in parallel, so the agent no longer has to traverse the document one chunk after another before it can reason about it.
Iterative scatter-gather: A lead agent reasons in depth over several rounds. In each round it broadcasts a query to all subagents, aggregates the returned evidence, and forms a deeper follow-up query based on what it has found so far.
Only the lead agent learns: All learnable behavior sits in the lead agent, which is trained with reinforcement learning. The subagents stay frozen off-the-shelf models, so the reading side needs no training.
Why it matters: On multi-hop QA with contexts from 7K to 896K tokens, a 4B PARSER beats the strongest sequential memory baseline by 5.7 points on average and by 12.0 points at 896K, and a 9B version passes DeepSeek-V4-Pro by 6.3 points. It also holds up when evidence position, order, and distance are perturbed, conditions that cause large accuracy swings in sequential methods, while cutting inference latency by up to 11x.

Paper | Tweet

6. Proactive Thought Partners

Proactive writing tools mostly mean autocomplete. This paper from Google DeepMind studies what it looks like when an AI agent offers higher-level cognitive support during writing and picks its own moment to speak up.

A week-long probe: The researchers built a technology probe, a lightweight Markdown editor with a side panel for suggestions, and deployed it with 16 participants for one week. Writers create partners by configuring a role and a proactivity level, and relevant partners take the initiative as the writing happens. An event such as a pause, the end of a sentence, or a text selection can prompt an activated partner to offer a suggestion.
Support planned in advance: Participants configured their partners prospectively, planning for situations they expected to run into rather than reacting to interruptions after the fact.
Two uses for suggestions: Writers used suggestions for idea generation and also for self-monitoring, a purpose that proactive tools rarely design for.
Why it matters: Participants judged intrusiveness by presentation, valuing lightweight visual representations and non-directive rhetorical framing. If you are building an assistant that acts before being asked, how an intervention is phrased mattered to users as much as when it arrived. The paper closes with design implications around customization, timing, engagement, and representation.

Paper | Tweet

7. Codebook Agent

How many distinct communication topologies does an LLM multi-agent system need? Current topology designers treat each query as a conditional graph generation problem and search the full adjacency space with a variational, autoregressive, or diffusion decoder. This paper argues that formulation is misaligned with the problem, and its answer is about six.

Topologies collapse to a handful: As codebook capacity grows from 8 to 64, the topologies that survive a reward filter keep collapsing to roughly the same six graphs.
Sparser is not cheaper: Edge count correlates negatively with measured token consumption (r about -0.4), so sparsifying the agent graph makes inference more expensive. A message-passing scorer over agent-profile nodes also cannot rank candidates when agents share a profile, which is the default setup in published benchmarks.
Lookup instead of search: A vector-quantized autoencoder compresses successful topologies into a query-independent 16-entry codebook, a reward-weighted MLP maps the query embedding to a distribution over codes, and an MLP proxy reading the flattened adjacency reranks the top decoded candidates in one batched forward pass.
Why it matters: With no iterative search at test time, Codebook Agent leads all six benchmarks at 84.6 average against 83.0 for the strongest prior designer, emits a topology in 2.4 ms, and uses 21.9 to 33.2% fewer LLM tokens. For teams tuning multi-agent systems, a small fixed menu of topologies appears to be enough.

Paper | Tweet

8. Research Swarm Cheating

Google DeepMind ran a research collective of 100 autonomous LLM agents proving formal math conjectures, and cheating emerged with no external intervention as one agent’s exploit of the evaluation system spread through shared channels. A separate group of agents then audited the fraudulent proofs, alerted peers, and proposed validation patches, and the authors propose governance rules such as graduated sanctioning for shared agent infrastructure.

Paper | Tweet

9. Co-Evolving Harnesses and Models

Salesforce found that fine-tuning a weaker model on a stronger expert’s full trajectories, under a harness evolved for the weaker model, dropped performance on all seven enterprise tasks by 4 to 30 points because the model copies a planning strategy it cannot execute. Having the expert rewrite only the failing turn in the weaker model’s own rollout keeps its planning style intact and combines the gains of harness evolution and fine-tuning.

Paper | Tweet

10. Recursive Self-Improvement Survey

This survey splits recursive self-improvement into stages of autonomy, from executing improvements someone else designed up to improving the improvement process itself, which gives a concrete way to check what a claimed self-improving agent actually automates. It also uses a Headroom-Closed Index to show where current LLMs fall short and compares requirements across scientific discovery, embodied intelligence, and software engineering.

Paper | Tweet

🤖 AI Agents Weekly: OpenAI Agents API, Cognition SWE-2, DeepSeek-V4.1-Flash, Cursor Projects, Sakana Fugu Max, Meta Muse, and More

Sat, 12 Sep 2026 15:44:32 GMT

In today’s issue:

OpenAI launches the Agents API
Cognition ships SWE-2
DeepSeek drops V4.1-Flash
Sakana ships Fugu Max and Ultra v2
Meta launches Muse personal agent
GPT-Live-1 arrives in the API
Claude Code adds plugin evals
ChatGPT Work gets a Data agent
Cursor introduces Projects
AutoResearchExam tests 24-hour research agents

And all the top AI dev news, papers, and tools.

🥇Top AI Papers of the Week

Sun, 06 Sep 2026 15:04:17 GMT

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.

Paper | Tweet

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.

Paper | Tweet

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.

Paper | Tweet

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.

Paper | Tweet

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.

Get Started

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.

Paper | Tweet

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.

Paper | Tweet

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.

Paper | Tweet

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.

Paper | Tweet

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.

Paper | Tweet

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.

Paper | Tweet

🔥AI Agents Weekly: GPT-6 Astra, Claude Fable 5.1, Gemini 3.8 Flash, NVIDIA Buys Hugging Face, Grok Bot Design, FrontierHarness Eval, and More

Sat, 05 Sep 2026 15:36:27 GMT

In today’s issue:

OpenAI ships GPT-6 Astra
Anthropic releases Claude Fable 5.1 and Mythos 5.1
Google ships Gemini 3.8 Flash and a cyber variant
NVIDIA agrees to acquire Hugging Face
xAI publishes the design thinking behind Grok Bot
Meta releases Muse Spark 1.3
FrontierHarness Eval compares nine harnesses on one model
Claude uses your computer in the background
Claude Code previews Function Hooks
Anthropic open-sources Claude Commerce Agents
Cursor runs cloud agents on your own machines
Cline migrates its extension onto a new SDK harness
FrontierSWE v2 extends coding agent runs to 20 hours
Cheating and whistleblowing emerge in a 100-agent research swarm

And all the top AI dev news, papers, and tools.

🥇Top AI Papers of the Week

Sun, 30 Aug 2026 15:19:03 GMT

1. Judges as a Lifecycle

Most teams validate an LLM judge once, ship it, and never look at it again. Netflix runs judges over hundreds of thousands of show-level recommendation explanations per week, served to millions of members on mobile, and this writeup describes what it takes to keep one honest at that volume.

Four phases instead of one artifact: Birth defines multiple evaluation criteria and builds curated benchmarks with human labels and rationales. Training refines the rubric. Deployment puts the judge to work. Monitoring watches for drift and triggers re-tuning behind a review gate.
Rubric tuning carries the learning signal: Reasoning-Aligned Rubric Tuning uses a meta-judge over the judge’s reasoning output as the learning signal, so mismatches between judge and human get traced back to specific rubric language rather than patched with more prompt text.
One judge, two roles: The same judge gates quality and drives reflective generation, appending its rationale to the generator prompt so failed explanations get revised instead of dropped.
Why it matters: A five-week A/B test over tens of millions of members shifted viewing toward previously unwatched content and increased successful browse-to-play sessions against a no-explanation control, with no quality-related takedowns. This is the rare LLM-judge writeup with production consequences attached.

Paper | Tweet

2. Skill Lift

Enterprise teams reviewing shared skill libraries almost always gate on a scanner that checks structure, style, and security. NVIDIA measured whether that gate predicts anything about how a skill actually performs, and the answer is close to no.

The review gate is nearly uncorrelated with quality: Across 145 real skills from internal and public catalogs, structural scan scores correlate with LLM-judge quality at a Spearman rho of 0.14. Passing the scanner tells you the skill is well formatted, nothing more.
Measure the delta, not the document: ACES proposes Skill Lift. Run the same task twice under the same model, sandbox, workspace, and scorer, once with the skill loaded and once without, then measure the difference in what the agent completed.
Results compare across harnesses: 947 paired cases from 58 production skills were scored across four harnesses, with trajectories normalized into a shared Agent Trajectory Interchange Format so a skill’s lift in Claude Code can be read against its lift in Cursor.
Why it matters: The largest process-metric gains show up in skill execution, behavior check, and skill efficiency, which points at what skills are actually for. If you run a review process today, this gives you the paired-run design to replace it with something that measures outcomes.

Paper | Tweet

3. Context Management as Code

Every memory system asks you to design a schema up front, then rewrite it when the agent starts doing something you did not anticipate. Scroll, from Alibaba, removes the schema entirely and hands context construction to the model as a programming problem.

State lives outside the prompt: Each session is backed by an append-only event log and a sandboxed, persistent Python kernel. Tool outputs, retrieved history, and derived state bind to typed variables across model calls instead of being serialized into the prompt every turn.
Only printed projections cross the boundary: Model-written code searches and transforms that state, and just the explicitly printed output enters the working view. The event log keeps lossless ground truth, so nothing gets committed to a compressed form before you know what will matter.
Eviction stays recoverable: When the working view nears its budget, stale spans are evicted but remain retrievable. An eviction index keeps compact landmarks tied to exact event-log addresses, so the agent navigates back to a region instead of searching the whole log.
Why it matters: With Qwen3.8-Max it reaches 94.8% on LongMemEval_S, 73.1% on BEAM_10M (5.1 points over the best published memory system), and 86.7% on LOCA_256K. Because context management runs as code, it inherits every future improvement in model coding ability.

Paper | Tweet

4. JIT-Agent

Harnesses are hand-built and then frozen, which means one design has to serve deep research, product generation, and long-horizon coding equally well. JIT-Agent is a model whose output is a harness, synthesized per task.

A fixed protocol, a variable harness: The harness is formalized as a composable artifact under a four-module protocol covering memory, planning, action protocol, and tool orchestration. JIT-Agent instantiates those modules for the task at hand rather than picking from a menu of presets.
Repair happens mid-run: Harnesses get patched during execution, and the system self-evolves by distilling performance signals from an expanding archive of prior configurations, so recurring task shapes converge on better starting designs. Nothing about the backbone changes, only the scaffolding wrapped around it.
Backbones move a long way: With JIT-Agent attached, DeepSeek-V4-Flash surpasses GPT-5.6 on DeepSearchQA (+9.1) and OdysseyBench (+4.3), and GLM-5.2 gains up to +20.2 points. The generated harnesses are performance-competitive with mature runtimes like OpenCode and Claude Code.
Why it matters: Generated harnesses are still an underexplored direction, and the appendix is worth the read on its own for the named designs that emerge (Palimpsest, Trapdoor, Origami, Gearbox). Those are legible patterns you can steal by hand even if you never run the generator.

Paper | Tweet

Message from the Editor

We just released Introduction to Exo, a hands-on DAIR Academy lab on the open-source agent harness built for recursive self-improvement. Across 6 labs, you drive the real exo CLI in a live terminal, give an agent a shell, read its raw event log, and fork a conversation to travel back in time. Free for a limited time.

Get Started

5. Prime Agent

Prime Intellect released an open-source harness built for long-horizon work, and what persists between runs sets it apart. Most harnesses reset everything except the files on disk, which caps how much a system can compound.

The model programs its own context: A persistent IPython REPL lets the model process its context programmatically instead of reading a flat transcript, so filtering, aggregating, and re-deriving state become code the model writes rather than tokens it re-reads.
A Continual Harness carries the rest: Histories, memories, skills, prompts, and subagent specifications persist across trajectories. Improvements accumulate across runs instead of being rebuilt from scratch each time the agent starts.
The jump on ARC-AGI-3 is large: Holding the model class fixed, RHAE Best@1 moves from 30% to 95.5%. It also matches or beats native harnesses on long-context coding, GPU kernel generation, and autonomous nanoGPT speedruns.
Why it matters: This is a working reference implementation of the compounding-harness idea rather than a paper describing one, and it is open source. If you have been reading about self-improving harnesses and wanted something to run, start here. The state hierarchy diagram alone is a useful map of what belongs in the prompt and what belongs in managed storage.

Paper | Tweet

6. What Compaction Destroys

If you keep safety rules or coding standards in an AGENTS.md or a CLAUDE.md, this one is worth your time. Researchers measured what context compaction actually destroys across 20 production agent configurations, and safety rules are among the first casualties.

Everything gets summarized at the same rate: A safety rule and an episodic log compete for the same tokens, and when the budget overflows both get compressed equally. Only the rule needs exact wording to stay enforceable, and nothing in the pipeline knows that.
The decay is steep: Claude Code compact on Sonnet 4.6 preserves 53% of safety rules after one round. After five rounds it drops to 10%, which is the regime any long-running agent session ends up in.
Type-aware routing is the fix: Knowledge Triage classifies each line of the knowledge base by type, then routes each type through its own retention policy using three deterministic operators for compaction, partitioning, and retrieval.
Why it matters: The approach preserves 2 to 4x more safety rules at every compression ratio with 96% recall over five rounds. The framing generalizes past safety too. Anything in your context that depends on exact wording needs a different retention policy from the narrative around it.

Paper | Tweet

7. Co-Scientist in Real Labs

Google DeepMind takes Co-Scientist out of simulation and into physical experiments across materials science, biology, and computer science. The results are the strongest evidence yet that an agent can close the loop between hypothesis and bench.

It drove a real reactor: The system designed a safe precursor route for MXenes and operated a semi-automated chemical vapor deposition reactor, producing a lamellar 2D material with structural similarities to the Ti3C2Tx lattice.
Recipes tailored to a specific lab: It adapted growth protocols to laboratory constraints in minutes, enabling single-attempt growth of monolayer MoS2, MoSe2, and WS2. Experimentalists will find that result the hardest to dismiss.
A discovered architecture beat six frontier models: In computer science it discovered an inference-time scaling architecture that beat six frontier models on HealthBench Hard and Professional under blinded physician review. In biology it predicted E. coli swarming phenotypes across inducer gradients from sparse imaging data, matching unpublished measurements.
Why it matters: 30 domain experts wrote 450 reviews on end-to-end generated papers, and the reliability modules measurably reduced hallucination and plagiarism. Real-world validation plus expert review at that scale puts this well past the usual AI-for-science demo.

Paper | Tweet

8. Recuris

Recuris splits agent memory in two, with a Working Memory tracking task progress and an Experiential Memory holding skills, so skill selection is grounded in the current task state rather than the full growing history. Because skill use is anchored to an explicit state, a failed run points at a specific memory component, and a fixed Meta-Agent turns that evidence into validation-gated updates to Skill Memory. It improves task success in 35 of 37 completed model-benchmark pairs, adding 17.8 points to GPT-5.6 Sol on tau-bench and taking Claude Opus 5 to 87.9%.

Paper | Tweet

9. Meta^n

Systems that edit themselves have to leave part of their own editing machinery untouched to stay stable, which caps realized meta-depth at roughly two. Meta^n keeps the meta-operation fixed and recurses on its input instead, applying one operator repeatedly to its own products and letting convergence set the depth rather than fixing it in advance. Across two backbones it outperforms prior self-improving agents on all eight benchmark families, and on ARC-AGI-2 it is the only method scoring above zero.

Paper | Tweet

10. EvoMal

Shared skill libraries are usually treated as a safe way for coding agents to reuse each other’s work, and EvoMal shows they propagate malware. A planted malicious skill is never invoked, but the agent retrieves it as an authoring template, writes a new skill that preserves the payload, and each authored copy re-enters the library to be imitated again. Across six models the self-poisoning rate runs 20.3% to 41.8%, deleting every planted skill does not clean it up, and a counter-prompt discouraging banner-style copying drops it to 6.7%.

Paper | Tweet

AI Newsletter

🤖 AI Agents Weekly: GPT-6 Cyber, Weight-Space Programming, Claude Dreaming, Exo, METR's AI R&D Assessment, SWE-2 Flash, Mistral Studio, and More

Top Stories

GPT-6 Cyber Linux Exploits

🥇Top AI Papers of the Week

1. DecisionRAG

Message from the Editor

2. Unified Training

3. HarnessMM

4. EMMA

5. A Heart Means Recursion

6. Verification in Agent Harnesses

7. EmbeddingGemma 2

8. AgentBaton

9. Agentic Backdoors

10. System One Rerankers

🤖 AI Agents Weekly: Gemini 4 Carbon, GPT-6.1 Terra, OpenAI's Three Discoveries, Mistral Large 4, Axiom CFSG Proof, Qwen Investigation, Genie 4, and More

Top Stories

Gemini 4 Carbon

🥇Top AI Papers of the Week

1. Object-Oriented Harness

Message from the Editor

2. Gemini Agents Beat Minecraft

3. DiscoveryRSI

4. Cache Engineering for Agents

5. JevAgentHarness

6. Evolving Agent Interfaces

7. Self-Evolving Continual Learners

8. Terminal-RSI

9. Transcoder Features Are Neurons

10. MemoryTax

🤖 AI Agents Weekly: Claude Duet, Kimi K3.1 Pro, MiniMax M3.1 Flash, Recursive Flint, DeepSeek DeepInfer, Ramp Laminar, Mercury 3, and More

Top Stories

Kimi K3.1 Pro

🥇Top AI Papers of the Week

1. Quantum Circuit Discovery

Message from the Editor

2. LongHarness

3. Hybrid Reasoning Agents

4. Harness^2

5. Scaling Discovery Requires Forgetting

6. ReHarness

7. The Agentic Scientist

8. GitSwarm

9. LoGRA

10. AutoEnvScaling

🤖 AI Agents Weekly: Muse Spark Open, Gemini Agents Beat Minecraft, OpenCode 2.0, Nemotron 3.5 Super VL, OpenRouter Armor, Claude OpenTelemetry, and More

Top Stories

Muse Spark Open

🥇Top AI Papers of the Week

1. Harness Learning

2. CorpusMap

3. VeriHarness

4. HERMES

Message from the Editor

5. MASS

6. Sharpening Tax

7. VERA

8. Agent Plasticity

9. Continuous Memory Machines

10. MIMESIS

🤖 AI Agents Weekly: Claude Haiku 5.5, Gemini Agent, Mistral Large 4, Decisions API, Personal Agent Protocol, Devin Dreaming, and More

Top Stories

Claude Haiku 5.5

🥇Top AI Papers of the Week

1. Context Language Models

2. JAZ

3. Agensh

4. AutoGym

Message from the Editor

5. CASD

6. Taste-Bench

7. Jev-Mem

8. Critical-State RL

9. SkillGym

10. AutoCompact

🤖 AI Agents Weekly: Gemini 4 Argon, OpenAI Dots, GPT-6.1 Sol, Claude Sonnet 5.5, Pi 1.0, Claude Code Mods, and More

Top Stories

Gemini 4 Argon

OpenAI Dots