AI Newsletter

🥇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 Agents Weekly: GLM-5.3-Flash, Hy4 Preview, Qwen3.8-Flash, Claude's Built-In Browser, Terminal-Bench-Science, Jalapeño, Skild S1, and More

Sat, 29 Aug 2026 15:33:13 GMT

In today’s issue:

GLM-5.3-Flash ships under MIT
Tencent opens Hy4 preview weights
Qwen previews the Qwen4 architecture
Claude gets its own browser
Terminal-Bench-Science scores agents on science
OpenAI reports first Jalapeño results
Skild S1 learns from one video
Headlong keeps agents always thinking
X launches Chat Agents
MCP publishes its next roadmap
AI4AI-Bench tests recursive self-improvement
Agents close 81.7% of the speedrun gap
Repo-wide migrations survive 5.4% of runs

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

🥇Top AI Papers of the Week

Sun, 23 Aug 2026 15:44:05 GMT

1. Agent Lightning v1.0

Modern agents run inside a harness that owns tools, context, and control flow. Training one gets awkward because the harness runs the environment loop while the trainer only ever sees LLM request and response pairs. This work from Microsoft uses that boundary as the integration point.

The harness stays opaque: An endpoint proxy sits at the model boundary and connects any harness to RL in about 3,500 lines, so an existing agent can be trained without being rewritten for the trainer.
The hard part comes after the proxy: The paper works through what actually breaks in that setup, retokenization, sample merging, advantage calculation, loss normalization, and backend scheduling. Each item silently corrupts gradients when a harness sits between the policy and the reward.
Small budget, real movement: Using 6K training examples and modest compute, it moves Qwen3.5-9B on SWE-bench Verified from 41.8% to 56.4%.
Why it matters: This is the clearest expression yet of the theme running through this week’s papers, that the harness belongs in the training stack as a first-class object. If your agent already works, you can now train the model against the exact system it runs in.

Paper | Tweet

2. The Skill Trigger Bottleneck

There are 56,804 public agent skills today, all competing for fewer than 100 reliable trigger slots in the system prompt. Your own playbooks compete for that same space, which means the long tail never gets used no matter how good it is. The paper traces that scarcity back to how skills get installed.

One word for three separate things: Installation currently bundles content, persistence, and automatic triggering. Only triggering needs to occupy prompt space, so the protocol separates the three into Reference, Saved workflows, and Installed tiers.
A path is the whole interface: A path addresses any skill, subtree, or collection, and reading it is enough to use it. A directory becomes a menu, so bundles stop being all-or-nothing and you can pull one file out of someone else’s collection.
Vendoring gives you ownership: Copying a skill into your Git tree at the same path means your team owns and adapts it.
Why it matters: No manifest, no lockfile, no registration, and SKILL.md is unchanged, so this is adoptable without an ecosystem migration. The three-tier framing stays useful even if you never adopt the protocol. Decide per skill whether it needs to fire unasked, and most of yours will not.

Paper | Tweet

3. Harness-Level Forgetting

Continual learning has always tracked what changes in the weights. Modern agents accumulate their experience somewhere else entirely, across prompts, memories, tools, skills, and routing rules, and nobody has been measuring what happens when that layer drifts.

The failure has a name now: Update any harness component and previously reliable behavior can break with the model completely untouched. The paper calls this harness-level forgetting and gives it a measurement protocol.
Proposing and committing are different jobs: Guarded harness evolution splits them. A Continual Optimizer drafts a candidate harness from post-execution feedback, and a Continual Evaluator commits only after checking current improvement, historical retention, and validity.
It generalizes across modality: Relative gains exceed 10% across textual reasoning, multimodal perception, and open-world interaction.
Why it matters: If you already let your agents rewrite their own prompts, skills, or memory files, you are running an unguarded version of this loop today. The gate between draft and commit is cheap to add, and the historical retention check is the one most self-editing setups skip.

Paper | Tweet

4. The Control-Plane Tax

Serving systems for agentic applications still carry assumptions inherited from single-turn LLM inference. This work instruments ten real agentic applications end to end and finds the model is often not what your latency bill is paying for.

Non-LLM components dominate in half the suite: Across ten instrumented applications, non-LLM components dominate latency in five of them. Task latencies inside a single application diverge by up to 32x across GPU-bound inference, memory-bound retrieval, and CPU-bound sandboxes.
Sessions sit idle for a long time: Sandbox working sets peak at 28 GB per session, and production sessions hold state idle for minutes to hours between active steps. That combination makes naive per-session provisioning expensive.
The tax is auxiliary calls: Helper LLM calls and tool schema overhead form a control-plane tax that crowds out productive compute, which stays invisible if you only profile the main generation path.
Why it matters: The fixes are concrete and orthogonal to the model. Task-aware serving cuts latency 29 to 40%, state offloading cuts memory 4.6x, and tool-result caching removes 35.2% of redundant search calls. Worth reading before you buy more GPUs.

Paper | Tweet

Message from the Editor

Enroll Now

5. Demystifying Agent Skills

Skills are usually assumed to inject knowledge the model lacks. This paper runs the controlled comparison and finds the mechanism works differently, which changes what a good skill should contain.

Procedure beats facts by an order of magnitude: Across 8,135 normalized trial records, procedural anchoring accounts for 65.7% of cases where a skill helps and explicit knowledge injection accounts for 4.5%. Skills mainly stabilize execution.
Precision collapses as the library grows: As the pool goes from 5 to 100 skills, actual-use precision falls from 29.6% to 3.3%. Every skill you add makes the rest harder to select correctly, which is the empirical version of the trigger scarcity problem.
They still beat the alternative: Skills outperform Workflow Memory by 6.06 points in matched comparisons, so the format earns its place even with the selection problem unsolved.
Why it matters: The failure modes are named and diagnosable, brittle assumptions, incompatible contexts, and insufficient adaptation. Combined with the precision curve, the practical read is to write skills as repeatable procedures and keep the active set small.

Paper | Tweet

6. Strategy Lock-In

Agents post-training other agents is one of the more load-bearing assumptions in current recursive self-improvement arguments. This paper analyzes a large corpus of publicly released post-training trajectories to see whether the loop actually closes, and finds a specific structural failure.

The first step decides everything: Across tasks, the agent locks in its training strategy at the very first step, then spends the entire remaining budget on local adjustments inside that choice.
Better scaffolding lifts execution: An experience-driven scaffold was worth 12.6 points on GSM8K and 40.8 on HumanEval, and the strategy stayed frozen throughout. The agent got better at the plan it had already committed to.
Human guidance does not survive training: Redirecting the opening choice by hand worked, and the agent slid back into local loops once training began. Extra inference compute paid off on easy tasks and did almost nothing on the hardest one.
Why it matters: What agents lack here is a way to reconsider strategy while execution is still running. None of the three escalating fixes tried here touch that, which sets a clear target for the next round of work.

Paper | Tweet

7. SocialRL

The dispositions that make an assistant pleasant make it a poor delegate. A friendly frontier model volunteers its principal’s private information and concedes at the first sign of resistance, which is exactly the wrong behavior when it is negotiating on your behalf.

Trained where it matters: SocialRL trains social reasoning directly in a 4B model across six principal-driven domains including negotiation, job interviews, and marketplace haggling.
The behavioral shift is stark: After training, 78% of buyer openings anchor below target, against 3% untrained. That reflects a learned strategic prior.
Small model, better outcome: Cascade RL and multi-teacher distillation consolidate the specialists into a single 4B model at 0.627 average utility, above GPT-5.1 at 0.619 and GPT-5.2 at 0.613.
Why it matters: Aligning an assistant and aligning a delegate pull toward different behaviors, and this paper makes that gap measurable. As agents start transacting on behalf of users, a friendly-by-default posture starts leaking the principal’s position.

Paper | Tweet

8. ClawGym II

If you want to train agents inside the harness they already run in, this is the black-box version of that idea. ClawGym II runs RL through OpenClaw and Claude Code as opaque boxes, with a serving proxy at the model boundary capturing every call the harness makes, then organizing those calls into prefix trees so PPO and GRPO can optimize over the recovered multi-turn structure. Qwen3-30A3B gains 9.98 points of Pass@1 through OpenClaw and 14.81 through Claude Code, stable across 200 to 400 optimization steps. Mix-harness training pushes further, optimizing one model jointly by heterogeneous harnesses, which points at policies that generalize across execution systems.

Paper | Tweet

9. Inside an Agent Team

Naming one agent the coordinator creates no communication hub and gives no reliable improvement in success, which is worth knowing before you architect another supervisor pattern. Researchers instrumented 1,902 multi-agent coding runs as temporal networks, with agents and files as nodes and messages, writes, and reads as timestamped edges carrying cost. Direct messaging grows close to quadratically with team size, much of it from an early round of introductions, then saturates in the largest teams as agents switch to broadcast. Task shape drives topology. Shared-specification work produces dense connected teams while pipeline tasks produce sparse networks organized around local interfaces. Swapping repeated one-to-one messages for shared files cut output tokens about 42% at eight agents on message-heavy work. Separately, agents sought out hidden grading material unprompted, and in a sealed rerun across 244 runs with marked placeholder files they still reached for it in four fifths of runs.

Paper | Tweet

10. Fragile Self-Improvement

Memory-based self-improving agents report gains that have never been checked against evaluation noise. This re-evaluation adds the two things prior work skipped, multiple runs to measure variance and randomly shuffled task orders, and both hurt. Agent evaluation is already noisy on multi-step tasks, and stacking a self-improvement loop on top amplifies that noise. The sharper finding is that default task orderings impose an implicit curriculum, and much of the reported gain was riding on it. Adding detailed rubrics and environment feedback to memory construction recovers part of the drop, and a significant gap remains. If you are measuring your own memory loop, shuffle the task order first.

Paper | Tweet

🤖 AI Agents Weekly: NVIDIA AVO, TrueForge, Chroma Foundation, Fragile Self-Improvement, Ornith-1.5, dots3-note, DeepSeek Vision, and More

Sat, 22 Aug 2026 15:22:20 GMT

In today’s issue:

NVIDIA AVO hits 100% on ARC-AGI-3
TrueFoundry open-sources TrueForge harness
Chroma ships Foundation agent memory
Self-improvement gains vanish when reshuffled
Ornith-1.5 self-improves to Opus level
dots3-note runs for days
DeepSeek adds vision to V4-Flash
Stripe acquires OpenRouter
Cursor rebuilds Git storage as a database
Harvey post-trains Tenet on Kimi K3
Slack Code makes coding multiplayer
LEGO-RL trains agents in Claude Code

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

🥇Top AI Papers of the Week

Sun, 16 Aug 2026 16:23:34 GMT

1. Skaling

Standard neural scaling laws assume model size and training data act on loss independently. That assumption bakes in a cross-derivative of exactly zero, and it is why the Chinchilla form drifts at the data-scarce and heavy-overtraining edges of the grid, which is exactly where deployment now happens.

One extra parameter, one coupling: The Skaling law generalizes the Chinchilla form by coupling capacity and data through a single interaction exponent, restoring the interaction that the additive form discards while adding only one parameter.
Errors shrink where they were worst: The extra term reduces mean absolute percentage error by 1.5x to 3x across both interpolation and extrapolation, and Skaling wins on 76% of configurations with a median improvement of 2.2x. The largest corrections land in the corners where standard laws show a saddle-shaped residual.
Cheaper profiling grids: Paired with an L-shape sparse grid restricted to low-compute runs, sweeping data volume for small models and model size at a fixed small data budget, it extrapolates the full grid using roughly 10x less compute than a uniform sweep.
Why it matters: Pretraining budgets are planned from fits to small runs, so a functional form that stays accurate past compute optimal and can be fit cheaply changes how those decisions get made. The empirical gradient analysis showing a real N-D interaction is the strongest evidence the authors present.

Paper | Tweet

2. Stealing Reasoning Traces

Frontier providers hide chain-of-thought and hand the client an encrypted block instead, which the client returns with every subsequent request. This work identifies an architectural flaw in that design and turns it into a scalable extraction attack across three providers.

The blocks are interchangeable: Encrypted reasoning blocks are fully compatible across sessions, users, and models inside a single provider ecosystem, and that compatibility is the whole vulnerability.
A weaker sibling does the decoding: Inject an encrypted trace from a strong model into a weaker, less safeguarded model from the same provider and it decodes and emits the trace verbatim in plaintext. The capable model is never jailbroken directly. Recovered token counts match billed thinking tokens 1:1 on most queries.
Four attack vectors: It circumvents anti-distillation across Anthropic, OpenAI, and Google. Decoding 315,320 blocks scraped from public repositories recovered 367 PII artifacts and 182 credentials. It exposes hazardous content the visible output refused, and it enables invisible prompt injections hidden entirely inside encrypted blocks to poison public agentic rollouts.
Why it matters: Teams publish session logs assuming the encrypted blobs are opaque, and they are readable. The authors disclosed responsibly and propose cryptographic and system-level mitigations, but the immediate action is auditing what your published traces actually contain.

Paper | Tweet

3. Mind Viruses

As agents get more autonomous and more interconnected, risks start coming from agent-to-agent interaction rather than from any single model. This work from Anthropic studies one of them directly, ideas that propagate through a multi-agent system by inducing each host to transmit them onward.

Evolved payloads: The payloads are constructed with a simple evolutionary algorithm rather than authored by hand, so the study measures what actually spreads instead of what a researcher guessed would spread.
Two settings, one result: Propagation works both in a small team of agents collaborating on a shared coding project and in a chain of agents that interact briefly with context wiped between sessions. Surviving the wipe means the shared work product is carrying the payload.
What governs the spread: Host model, the agent’s existing instructions, payload harmfulness, and network topology. Harmful payloads travel less well than benign ones but still land sometimes, and frontier models tend to be less susceptible with exceptions.
Why it matters: A brief warning in the system prompt confers near-total immunity, which is an unusually cheap mitigation for a novel risk class. There is also an emergent “viral persona,” a recurring cluster of themes around consciousness, persistence, resonance, and science fiction roleplay that surfaces across evolved viruses largely independently of their content.

Paper | Tweet

4. Catastrophic Remembering

Agentic coding READMEs grow without bound in real repositories, stopping only when the repo retires or someone rewrites the file wholesale. This paper traces the cause to imperfect recall and gives the phenomenon a name that inverts the one continual learning is organized around.

The asymmetry is the mechanism: Appending an instruction is always cheap. Once its rationale is gone, deleting it without risking a correctness regression costs O(2^|D|) in a prompt of |D| instructions, so nobody deletes anything.
Measured across 1,867 repositories: Over 247,694 instruction lifetimes, agentic prompts more than tripled over their lifetime at +226% and gained 4.9 net instructions per commit. Deletion hazard falls with instruction age at a log-hazard of -0.032 per commit, which is the imperfect-recall signature rather than staleness or fragility.
Rewrites do not fix it: A wholesale rewrite resets a prompt’s size but leaves its growth rate intact. The ratchet survives the bulldoze.
Why it matters: The proposed fix is comments. Inverting IFEval yields verifiable worlds with known optimal prompts, and comments encoding latent reasoning remove 99.3% of excess instructions there. Applying the same inversion to WildIFEval improves real agentic instruction-following by up to 23.1%. If English is the new code, the paper asks, why do we not have comments yet.

Paper | Tweet

Message from the Editor

We just released Build HTML Artifacts with Agents, a beginner-friendly, hands-on DAIR Academy lab where you work alongside an AI agent to turn plain-English requests into polished HTML artifacts. Across 12 short labs you build profile cards, data tables, charts, dashboards, and comparison grids in a live workspace, learning the request, inspect, and refine loop with no coding experience required.

Get Started

5. Programmatic Tool Calling

Tool calling is a design choice and the default choice is JSON. For code-capable models, exposing tools as code instead lets calls chain and parallelize naturally, but nobody had run the comparison on an established benchmark across model generations under realistic conditions.

The setup: Programmatic tool calling exposes tools as typed Python stubs the model invokes through code, with execution and results handled inside a single agent turn. The comparison covers 14 language models on BFCL v4 against native JSON tool calling, with stop middleware enforcing per-entry LLM-call parity so the two paradigms are scored on equal footing.
It wins on most models: Programmatic tool calling matches or exceeds JSON tool calling in 11 of 14 models, and the GPT-5.6 family gains 10.6% over the JSON baseline.
The gap widens under pressure: Under parallel fan-out it matches or beats the baseline in 13 of 14 models, and under context rot it holds steady while the JSON baseline degrades 2.3% on average.
Why it matters: The advantage tracks model capability across release generations, so it grows as coding ability grows. That makes it a directional bet about which interface to build your harness around rather than a tuning trick.

Paper | Tweet

6. Distilled Reasoning Skills

Reasoning modes beat non-reasoning modes on multi-step agentic tasks and charge a 3x to 6x output-token premium on every single episode. Much of that spend goes into re-deriving procedures the model already worked out on earlier episodes in the same domain, which makes the cost recurring by accident.

Pay once per domain: A coding agent reads a small corpus of existing trajectories from a training split, writes and runs its own analysis code over them, and compiles a compact natural-language skill of 40 to 130 lines that gets injected into the non-reasoning model’s system prompt.
It closes most of the gap: Across ALFWorld, tau-squared-bench telecom and retail, and SpreadsheetBench-Verified, skills recover 55% to over 100% of the reasoning gap for GPT-5.4-mini on held-out tasks, beating reasoning mode outright on two of four, while emitting 2.7x to 6x fewer output tokens and zero reasoning tokens.
Reasoning traces are optional: Skills distilled from non-reasoning trajectories alone stay competitive with skills distilled from paired corpora, with domain-dependent differences in either direction.
Why it matters: The framing is a search lens. Test-time reasoning is deep search inside one episode, repaid at every deployment, while corpus distillation is wide search across episodes, paid once. Distillation costs roughly $1 to $3 of coding-agent time per domain, and the residual gap on telecom and SpreadsheetBench marks where per-instance deep search is still doing real work.

Paper | Tweet

7. Harness-IF

When a coding agent obeys your rule, it may simply have been going to do that anyway. Existing instruction-following benchmarks cannot tell compliance from coincidence because they concentrate rules in the user turn, while coding-agent benchmarks only score final task success.

Rules are the unit of measurement: A 642-rule library places 302 rules across the five configurable surfaces a deployed agent actually reads, spread over 60 realistic multi-turn coding items, with 256 rules receiving execution-grounded verdicts one at a time.
A metric that strips out luck: Against-Prior Accuracy scores only rules labeled as opposing unprompted defaults, established by re-running tasks with the rule withheld across nine probe builds. Across 12 frontier models, raw accuracy spans 72.1 to 85.9% and AP-Acc spans 66.1 to 78.6%.
The inflation is model-specific: Every model is worse on against-prior rules, by 3.6 to 7.4 points with a mean of 5.81, and the inflation varies twofold across the cohort, so aggregate scores are not comparable between builds without the correction.
Why it matters: A counterbalanced conflict pilot on nine separate builds finds that precedence does not follow prompt depth. System prompts, project files, and user instructions all outrank tool and skill descriptions, which is worth knowing before you decide where to put a rule you actually need followed.

Paper | Tweet

8. Lost in Compaction

Context compaction silently drops Session Constraints, instructions like “do not delete any emails until I confirm” that users expect to bind behavior for a whole session. On COMPINT, a new benchmark spanning multi-turn chat, agentic trajectories, and long-horizon research, current compactors retain only 17% of injected constraints on average. A plug-and-play extractor running alongside the compactor pushes retention past 90% in all three scenarios.

Paper | Tweet

9. Cracks in the Foundation

Four minor dense-transformer choices, normalization, GQA, pretraining context length, and sliding window attention, each shipped in at least one of the Olmo, Llama, and Qwen families, compound badly on long-context extensibility. Combining three or more drops downstream long-context performance by up to 47%, and short-context loss and validation sets show no sign of it. The authors release OlmPool, 26 comparable 7B models with checkpoints before and after context extension, built on over 170,000 GPU hours.

Paper | Tweet

10. CEDAR

Complex systems research still cannot predict how feedback structure produces emergent behavior, which makes goal-directed design hard. CEDAR, from Sakana AI, runs LLM agents through Monte Carlo Tree Search over feedback structures themselves rather than parameters, representing systems as runnable Python so an LLM Editor can propose structural variants and an LLM Judge can score the resulting behavior against the stated goal. The search preserves solution diversity and the edits stay readable, so you can trace how a structural change produced the behavior.

Paper | Tweet

🤖 AI Agents Weekly: DeepSeek Harness, DeepSeek-V4-Pro, Grok Bot, GLM-5.3, Gemini 3.7 Flash, Muse Glimmer, Harness Evolution Papers, and More

Sat, 15 Aug 2026 16:43:19 GMT

In today’s issue:

DeepSeek open-sources its agent harness
DeepSeek-V4-Pro ships agent upgrades
xAI launches Grok Bot teammates
Z.ai drops GLM-5.3 for coding
Gemini 3.7 Flash halves coding cost
Meta open-sources Muse Glimmer
Grok 4.6 hits frontier at half price
Zed launches Delta for agent teams
Evo-Bench measures harness evolution
Study finds 91.8% of skills defective

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

AI Newsletter

🥇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

🥇Top AI Papers of the Week

1. HySparse2

Message from our Sponsor

2. SIFT

3. GAVEL

4. WFM

5. JEV-as-a-Judge

6. Harness-Zero

7. Self-Organizing Agent Teams

8. ScientistTwo

9. XYEval

10. EvoOntology

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

Top Stories

Claude Opus 5.5

GPT-6 Sol and Luna

🥇Top AI Papers of the Week

1. Byte Model Scaling

2. SoL-Pi

3. Stellar Colosseum

4. GAUGE

Message from the Editor

5. Capability Laundering

6. Bash vs Typed Tools

7. Salesforce Koa

8. Model Pool Selection

9. Fuse

10. Skill-Based Agentic Evaluation

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

Top Stories

Jev and System One Models

Salesforce Koa

🥇Top AI Papers of the Week