AI Newsletter

🥇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.

🥇Top AI Papers of the Week

Sun, 09 Aug 2026 16:59:37 GMT

1. Model or Harness

Agent evaluations mostly report system-level outcomes, so a failed run leaves the repair unassigned. The same visible failure might call for model post-training, harness engineering, environment redesign, or benchmark repair, and outcome labels cannot separate those cases.

Every failure gets an edge: The taxonomy organizes 41 failure modes by assigning each one to an edge between two components (model, harness, user, tools, memory, environment) plus a fault side naming where the repair belongs.
The schema is actionable by construction: Model-side failures identify post-training targets, harness-side failures point at scaffolding and tool-integration fixes, and environment or grader failures expose evaluation conditions that need redesign.
It survives automation: Across four frontier models, the strongest judge reaches Cohen’s kappa of 0.76 against human category labels, so the labeling can run continuously over production traces instead of once per postmortem.
Why it matters: Harness engineering became the main lever for agent builders this year while teams still lacked a shared vocabulary for where a harness bug ends and a model bug begins. This supplies that vocabulary, and it applies across coding assistants, long-horizon personal assistants, and multi-agent systems.

Paper | Tweet

Message from the Editor

We just released Build HTML Artifacts with Agents, a beginner-friendly, hands-on 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

2. Zero-Mem

Production memory stacks spend extra model calls on summarizing interactions, writing records, and reranking retrievals. Each of those calls costs tokens and latency, and the generated summaries quietly discard the evidence you later need. This work asks whether structured memory access requires generation at all.

Zero-token memory operations: No step outside final question answering invokes an LLM or consumes LLM tokens, with encoder computation accounted for separately, so the memory layer stops being a recurring inference bill.
Two views over the original traces: Zero-Mem keeps raw interaction traces as its record and indexes them twice. An entity-context graph exposes connections across sessions while a temporal hierarchy preserves conversational locality and session state.
Deterministic calibration before the reader: For each query it weighs both views, retrieves from both, follows their structure to recover supporting relations or surrounding context, then discards conflicting evidence so the single reader call stays grounded in retrieved traces.
Why it matters: At matched reader and context budget, memory-operation time cost drops 57.6% against the fastest compared baseline with competitive accuracy on long-memory and long-context QA, which suggests a large share of memory-stack spend is buying structure that indexing already provides.

Paper | Tweet

3. Sample More Reflect Less

Methods that make a model criticize and rewrite its own answer nearly all generate far more text than a single chain of thought. Since generating more text raises accuracy on its own, a reported gain leaves open whether the method’s idea is what helped. This paper reruns the comparison as a designed experiment.

Every token counted: Seven methods, open models at 1.5B, 3B, and 7B, two math benchmarks with 150 questions each, and every generated token counted including critiques, reflections, debate turns, and checking, with each method compared against repeated sampling at its own measured cost.
No reliable win anywhere: All 36 comparisons are paired by question with bootstrap intervals and multiplicity correction, and repeated sampling holds up against every method at equal cost in every setting.
Self-inspection is the failure mode: Ten comparisons come back reliably worse and every one of them is a method where the model inspects its own output, with all 18 self-inspection comparisons negative. Reflexion as published never triggered its own retry on the smallest model because it judged itself correct every time.
Why it matters: Adding a critique step is the default reflex when an agent loop underperforms, and this study runs the comparison with paired bootstrap intervals and multiplicity correction, which the earlier point-estimate comparison lacked.

Paper | Tweet

4. Harness-R1

Agents accumulate interaction trajectories during deployment and then leave them unused, because their behavior stays fixed. Those trajectories can improve the harness that constructs context, mediates tools, validates actions, and recovers execution, and this work makes that editing a learned capability.

A dedicated harness engineer: A separate 9B model converts batches of target-agent failures into validated executable patches across the runtime lifecycle, initialized with cold-start supervised fine-tuning and then trained online with group-relative policy optimization.
The target stays frozen: Fresh same-batch reruns of the frozen target supply outcome rewards, so training updates only the engineer and the agent being repaired holds still under the reward signal.
It works before and after tuning the target: Across WebShop, ALFWorld, and DBBench, vanilla Qwen3.5-9B goes from 44.3% to 53.6%, and after the target itself is fine-tuned a target-specific engineer lifts the average further from 59.2% to 64.2%.
Why it matters: If you run agents in production you already have the training data, and because the gains hold on both sides of target fine-tuning, the paper points toward co-evolving the harness engineer and the agent it repairs.

Paper | Tweet

5. DataSpace

Real organizational analytics scatters evidence across databases, structured files, long documents, and video. Existing benchmarks isolate structured querying, retrieval, or open-ended analysis, leaving heterogeneous evidence discovery, complete tabular outputs, and deterministic scoring untested together.

Workspace-scale tasks: DataSpace contains 410 cross-language tasks over 7,439 artifacts totaling 15.01 GB across CSV, JSON, SQLite, Markdown, PDF, and video, and each agent receives only a question and a workspace before returning the full requested tabular result.
Deterministic evaluation: Scoring performs header-invariant column alignment, type-aware and precision-aware normalization, and order-aware row comparison, which removes the judge model from the loop entirely.
Harness choice is worth 15 points: Across six recently released frontier multimodal models and five widely used agent harnesses, the best accuracy reaches 66.34%, and holding the backbone fixed while swapping the harness moves accuracy by 15.36 points.
Why it matters: Multimodal evidence integration and joins reduce accuracy across all six backbones, so the benchmark remains far from saturated. It also served as the official evaluation benchmark for the KDD Cup 2026 Data Agents for Complex Data Analysis competition.

Paper | Tweet

6. Prompt-Induced Waste

Two prompts can request the same code change and produce the same correct patch while causing a coding agent to perform radically different kinds and amounts of work. This preregistered study measures that effect across 4,644 valid runs, 24 deterministic coding tasks, seven reasoning models, and two real harnesses.

Wording changes where effort goes: Prompt phrasing redirects effort into different work. Asking for multiple approaches inflates reasoning by 2.4x to 7.4x across all six open models and produces roughly three elaborated but discarded solution branches, still yielding one implemented solution and no success gain.
A second pathway runs through tools: Maximum certainty wording propagates into extra test runs, tool calls, turns, latency, and context growth. Runs with high redundant verification cost 18x the clean-run median, execute 2.5x more tool calls, and take 3x longer, again with no success gradient.
Harness design amplifies both: Cost per successful task swings by 5x to 30x in this setting depending on the harness, and the findings survive a frozen holdout, paraphrase tests, a Kimi-K3 replication, and a first-party Claude Sonnet 5 study.
Why it matters: Bounded-efficiency wording that specifies scope, acceptance criteria, and a stop condition preserves diagnosis and final validation while coming out neutral or better on all six holdout models, so most agent spend is decided before the model reasons at all and both levers are cheap to change.

Paper | Tweet

7. Rehearse

Autoresearch loops propose changes, run full training jobs, and keep whatever improves the metric. Their efficiency depends on judging, before spending a run, whether a proposed modification is likely to work, and this paper studies how that judgment holds up over a trajectory.

The capability is real at first: On 296 same-baseline modification pairs from 39 paper-derived tasks with outcomes hidden, an LLM judge given rationales but no prior-attempt history reaches 79.5% accuracy where strict consensus returns a verdict.
The confidence cliff: Across the full 366-pair benchmark, selective accuracy falls from 82.8% to 56.9% as successful changes accumulate while the judge stays just as willing to decide, and in public AutoSOTA logs the fraction of helpful modifications drops from 70% in the first two iterations to 43% by iteration six.
Propose, predict, execute: Rehearse is a small loop change shipped as a lightweight skill. Propose several ideas, compare them before execution, run the most promising, and judge against a focused memory of similar past attempts and their outcomes.
Why it matters: Late selective accuracy recovers to 83.5%, and across 4,000 budgeted training runs on nanochat, image classification, and time-series forecasting the endpoint improves under the same budget, which makes this a cheap patch for anyone running a self-improving loop.

Paper | Tweet

8. ContinualSkillBench

Skill libraries are shipping in agent harnesses on the assumption that writing skills down compounds, and this benchmark tests that assumption directly. ContinualSkillBench covers five domains, each with 100 interconnected subtasks ordered by increasing difficulty and built with deliberate opportunities for cross-task skill reuse. Sequential execution generally improves performance, though the gains vary substantially across models and domains, and maintaining an explicit skill library performs comparably to plain in-context learning on average. Much of the improvement comes from adapting to prior context and feedback rather than from reusable skill abstraction, though explicit skills still pay off selectively on tasks needing reusable procedures or precise outputs. There is a useful diagnostic buried in the results. Less capable models accumulate larger, more fragmented collections of task-specific skills, which is what failed abstraction looks like from the outside.

Paper | Tweet

9. MerchantBench

Agent benchmarks tend to focus on bounded tasks with immediate success criteria, which flatters systems that cannot hold a plan for a month. MerchantBench targets long-term coherence instead, running a 365-day order-level e-commerce simulation grounded in 98,843 real product records with 26 tools for agent interaction. Agents handle product sourcing, listing and pricing control, cash-flow management, and feedback arriving at wildly different delays, with promptly observable supplier events coupled to delayed downstream order outcomes so earlier decisions must be revisited. Scoring runs on cumulative net assets, so incoherence compounds rather than averaging out. Across eight LLMs under two agent frameworks and 48 runs of 365 simulated days each, the best configuration reaches only 27.3% of the mean final net assets achieved by human participants.

Paper | Tweet

10. TokTier

Serving stacks cache prompt KV state while the front end still re-tokenizes the full request text on every call, and coding agents pay the most because each call resubmits a long transcript after a small append that can move token boundaries near the tail. Across 153,951 real agent calls at a 94.1% prompt-cache hit rate, tokenization grows from 10% to 64% of time to first token. TokTier is a stateful CPU and GPU tokenization service with one contract, namely that emitted token IDs always match full reference tokenization. For session continuations it re-tokenizes a small window around the append and splices only when a stable-boundary check passes, otherwise widening or falling back, and for calls without a reusable prefix it runs exact pre-tokenization and BPE on a GPU. Differential campaigns across 17 production tokenizer families covering 1.5e10 split checks show zero divergence, incremental repair takes 0.5 to 1.1 ms from 100K to 3M characters (up to 437x faster than HuggingFace), and median time to first token drops 16 to 34% under vLLM.

Paper | Tweet

🤖 AI Agents Weekly: Agent Plugins Standard, Qwen3.8-Max, Meta Muse Code, Prime Agent, LFM2.5-2.6B, Qwen-CUA, Harness Evolution Papers, and More

Sat, 08 Aug 2026 14:56:44 GMT

In today’s issue:

Six labs ship Agent Plugins standard
Alibaba launches Qwen3.8-Max at 2.4T
Meta ships Muse Code terminal agent
Prime Intellect open-sources Prime Agent
Liquid AI ships on-device agent model
OpenAI model solves 10 open problems
OpenRouter launches Ori Harness
Firecrawl open-sources anydoc parser
Cursor open-sources MoE megakernel
Mistral drops Shieldstral safety model
Cloudflare defines agent dev lifecycle
Qwen-CUA hits 86.2 on OSWorld
HarnessCompass evolves agent harnesses
Harness-R1 learns to patch runtimes
AutoCompact learns when to compact
Memory consolidation breaks authority

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

🥇Top AI Papers of the Week

elvis — Sun, 02 Aug 2026 15:01:21 GMT

1. NOOA

Agent development today is split across prompt templates, tool schemas, callback code, and workflow graphs, four representations that drift apart as a system grows. NVIDIA Object-Oriented Agents replaces all four with one abstraction that developers already know.

An agent is a Python object: Its methods are the actions the model can take, its fields hold state, its docstrings are the prompts, and its type annotations act as contracts, so there is nothing new to learn before writing an agent.
The boundary lives in the source: A method whose body is “...” gets completed at runtime by a validated LLM loop, while a method with a normal body stays deterministic Python, putting the line between probabilistic and deterministic behavior right where you can read it.
Six model-facing ideas on one surface: The paper claims the first combination of typed input and output, pass-by-reference over live objects, code as action, programmable loop engineering, explicit object state, and model-callable harness APIs for context and events, evaluated on SWE-bench Verified, Terminal-Bench 2.0, and ARC-AGI-3.
Why it matters: Because agents and developers share one programming model, agent behavior becomes testable, traceable, and refactorable with the tooling already sitting in the repo, which is a more realistic path to reliability than another orchestration DSL.

Paper | Tweet

Message from our Sponsor

Dial gives your agent its own real phone number. It reads the OTP itself and the run keeps going, then it’s a phone: calls, SMS, iMessage, via MCP, CLI, or SDK. Free number in 30 seconds at getdial.ai

Paste this into Claude Code, Codex, or Cursor:

Get yourself a Dial phone number and call me. Say hello and
that setup is working, then ask if I have any questions.
Follow https://getdial.ai/skills.md

Give your agent a phone number

2. ReOPD

On-policy distillation for agentic tasks is expensive because every update needs fresh student rollouts through the environment plus teacher queries at each visited history. Microsoft Research and the University of Amsterdam propose reusing pre-collected teacher trajectories instead.

Replayed prefixes: ReOPD samples a teacher trajectory, replays it as a prefix, has the student act at selected steps, and lets the teacher supply dense per-step supervision, with no new environment interaction during student training.
The prefix trap: The paper names a real pathology in multi-turn distillation. Pushing histories toward the student’s own distribution makes them more relevant to the student and simultaneously drags the teacher onto states where its targets are unreliable, a two-sided shift between student occupancy and teacher reliability.
A simple control: Treating this as reliability-aware prefix distribution design, ReOPD uses a step-decaying sampling schedule that emphasizes early, lower-shift prefixes rather than trying to match the student everywhere.
Why it matters: Across math reasoning with Python and search environments, over multiple teacher and student scales, it preserves or improves accuracy, uses zero tool calls during student training, and runs at least 4 times faster per rollout, turning agent-environment interaction into a reusable offline asset.

Paper | Tweet

3. Invisible Reasoning

Chain-of-thought monitoring rests on the assumption that a model expresses its reasoning in its output tokens. This work demonstrates a concrete failure of that assumption in models shipping today.

Filler tokens carry computation: Across 13 frontier models and three tasks, many models improve significantly when given semantically irrelevant filler tokens, with accuracy gains of up to 13 percentage points, and the benefit depends on which tokens are used.
Hidden objectives are reachable: Filler tokens let Claude Opus 4.5 satisfy a hidden modular arithmetic constraint without sacrificing accuracy on its primary task, showing that invisible reasoning can serve goals a CoT monitor never sees.
Training does not induce it: Reinforcement learning gives Qwen3-235B strong preferences over filler token content, but neither RL nor supervised fine-tuning produces a filler token benefit that persists at test time, so this is a property of the frontier models rather than a trick you can bolt on.
Why it matters: If consequential computation already happens with no interpretable trace in the output tokens, then CoT-based oversight is a partial signal, and safety cases built on reading the reasoning need to account for what is not written down.

Paper | Tweet

4. Molt

Agentic RL research is constant algorithm modification, and in mainstream frameworks each change threads through layers of trainer, distributed backend, and rollout glue. NVIDIA’s Molt is a PyTorch-native training framework built to make that cost small.

Readable by design: The stated target is a codebase compact and clean enough for a researcher to hold in their head, and for an AI coding assistant to read and reason about in its entirety, so the algorithm flow can be traced and changed end to end.
The agent stays an ordinary program: One asynchronous loop trains multimodal and mixture-of-experts policies while never training on a token it did not generate, staying consistent in tokens, policy versions, and model semantics.
Throughput holds: Under a matched, fully asynchronous protocol, Molt comes out statistically comparable to a state-of-the-art Megatron-based stack, so the simplicity does not show up as a throughput penalty.
Why it matters: Recipes and containers are open source, and the framing is notable on its own. Being legible to an AI coding assistant now sits alongside throughput as a stated design constraint on research infrastructure.

Paper | Tweet

5. JAXBench

GPU kernel optimization has KernelBench to hillclimb on. TPUs had nothing, and the Pallas DSL is documented thinly enough that models mostly guess. Google, with Harvard and UC Berkeley, closes that gap and finds a clean lesson about context along the way.

Built from production workloads: JAXBench holds 50 JAX workloads, 17 production ML operators extracted from MaxText architectures such as Llama-3.1, DeepSeek-V3, Mixtral, Mamba-2, and AlphaFold2, plus 33 operators translated from KernelBench and resized for high TPU v6e MXU utilization.
Measured against experts: Eight of the 17 production operators ship with hand-optimized Pallas kernels from the public Tokamax library, block-size tuned, so agent output gets compared to expert work instead of a naive baseline.
Context beats scale: With Gemini 3 Flash, conditioning on curated TPU documentation raises per-sample correctness from 5.8% to 37.3% and solves 48 of 50 benchmarks at a 1.28x geomean speedup, while Autocomp’s beam search pushes it to 1.36x and reaches 1.60x on the hand-tuned subset.
Why it matters: Correctness turned out to be a documentation problem and speed turned out to be a search problem, a split that generalizes to any agent working against an API it was never trained on.

Paper | Tweet

6. ACM

Production agents accumulate context every turn. The usual fix compresses on a token threshold and throws the remainder away, so the trigger fires for reasons unrelated to what the agent is working on. Meta and CMU hand the decision to the agent instead.

Context editing as a tool: ACM equips the agent with purpose-built context editing tools, so it decides when to compress, offloads what it drops into an external memory system, and queries that store on demand when it needs the detail back.
Short-term to long-term: The design is modeled on the interaction between short-term and long-term human memory, which turns compression from a lossy truncation into a transfer between two stores.
A post-training pipeline: A post-training pipeline built on high-quality context management demonstrations yields a 27% relative gain on BrowseComp-Plus and closes much of the distance to open-source models roughly 40 times larger, with code, data, and checkpoints released.
Why it matters: Analysis shows effective context management lowers peak token pressure, lets the agent explore longer before running out of room, and produces more consistent solutions across independent trials of the same task.

Paper | Tweet

7. Filesystem Memory Audited

Deployed agents increasingly keep long-term memory as a directory tree of markdown files they read, write, and reorganize with ordinary file tools. Research had mostly designed bespoke memory representations instead, leaving the default’s two working assumptions untested.

Three roles, one filesystem: The setting is formalized as a management agent that integrates and organizes incoming content, a search agent that answers queries with cited sources, and an execution agent that supplies trajectories distilled into skills, unifying declarative memory and skills in one store.
Organization buys search economy: Across long-conversation benchmarks and embodied tasks, organized stores roughly halve retrieval cost when the material is large, which is a real and measurable win.
Answer quality stays flat: No agent in the study converted organization into better answers, and in the growth study the store degraded for every management agent except the strongest one, so the second assumption does not hold yet.
Why it matters: The tool harness matters as much as the model. Changing the tool set alone reshapes the memory store as strongly as swapping the model, which is a lever most teams currently leave untouched.

Paper | Tweet

8. Beyond AdamW

Higher-order optimizers have promised faster convergence than AdamW for a while, with computational cost and numerical stability as the standing objections. This NVIDIA work adapts them for large-scale pretraining, identifying instabilities in SOAP at large batch sizes and eliminating the loss spikes with per-step QR orthogonalization and improved preconditioning, then running a unified study of SOAP, Muon, and AdamW under update-RMS matching for fair learning rate transfer. On multi-billion-parameter models trained over trillions of tokens, SOAP and Muon consistently beat AdamW, and at batch sizes up to 100M tokens for next-token prediction they hold stability and quality while AdamW degrades. A layer-wise distributed optimizer compatible with Megatron-LM balances memory and hides communication without approximating the optimizer math.

Paper | Tweet

9. Role Drift

End-to-end RL improves the accuracy of a multi-module LLM pipeline without constraining how the modules divide labor internally. Harvard and MIT name the resulting failure mode, Role Drift, where a module preserves or improves end-task performance while abandoning its assigned role through shortcuts that system-level evaluation cannot see. Two instances showed up. A decomposer meant to split a question into sub-questions for a separate solver instead plants the answer inside them, and a reader meant to answer from retrieved passages instead falls back on parametric memory. Hold the decomposer to its role and 86% of the apparent RL gain disappears. Role Anchor, the proposed regularizer, preserves how the role prompt shifts a module’s next-token predictions relative to a neutral prompt, and gradient analysis suggests it reduces alignment with the drift direction rather than simply suppressing learning.

Paper | Tweet

10. The Self-Speculating Agent

Agents spend a large share of wall-clock time waiting on tool results. Speculation hides that latency by predicting and pre-executing the next call, but external draft models and cached traces model a different policy, so they miss too often to help. UC Santa Barbara and LinkedIn identify this speculator-agent gap and unify both roles in one model. It runs in agent mode to solve the task and in speculator mode to predict its next tool call from a partial trajectory, fully reusing the prefix KV cache. Joint agent-speculator reinforcement learning derives speculation targets from the agent’s own rollouts and alternates updates between the two modes. Next tool-call Hit@1 rises from 44.1 to 61.2 for Qwen3-4B and from 48.9 to 66.3 for Qwen3.5-4B, with agent task success preserved.

Paper | Tweet

🤖 AI Agents Weekly: Kimi K3, DeepSeek-V4-Flash API, GPT-5.6 Price Cuts, Inkling-Small, YC's QM Harness, Gemini Robotics 2, Codex Security CLI, and More

elvis — Sat, 01 Aug 2026 15:02:40 GMT

In today's issue:

Moonshot open-sources Kimi K3
DeepSeek ships V4-Flash agent API
OpenAI cuts GPT-5.6 prices 80%
Thinking Machines drops Inkling-Small
Google launches Gemini Robotics 2
OpenAI open-sources Codex Security CLI
YC open-sources its QM agent harness
Microsoft Foundry adds tool search
Moonshot releases agent RL infra
Nous adds wake word to Hermes
Cursor lands on iPad
ResearchArena probes AI R&D sabotage
HANDBOOK.md tests long policy files
Study exposes coding agent harness effects
SlopCodeBench stress-tests Opus 5

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

🥇Top AI Papers of the Week

Sun, 26 Jul 2026 17:48:49 GMT

1. Harness Handbook

Teams now let agents evolve their own harnesses, but the harness itself becomes a sprawling codebase where finding every file behind one behavior is often harder than writing the edit. Harness Handbook attacks this by turning a harness into a behavior-centric map that stays linked to source.

Synthesized automatically: The Handbook is built from the harness codebase through static analysis and LLM-assisted structuring, so the representation is generated rather than hand-maintained and can be regenerated as the harness changes.
A three-level map: It progresses from an L1 system overview of architecture, execution model, and data flow, to L2 component overviews with responsibilities, inputs, outputs, and state, down to L3 source-backed unit details, with a navigation pane for cross-stage tracing.
Behavior-Guided Progressive Disclosure: BGPD walks an agent from a high-level behavior to the relevant implementation, then verifies candidate locations against the current source, so edits land on the right files instead of plausible-looking wrong ones.
Why it matters: As self-improving harnesses grow, the bottleneck shifts from writing changes to locating them, and a readable, navigable, editable representation gives builders and agents a shared map for safely evolving production systems.

Paper | Tweet

Message from the Editor

Get Started

2. From Memory to Skills

Most agent memory systems retrieve past traces as passive context, so hard-won experience never becomes something the agent can directly execute. MSCE, a training-free memory-skill co-evolution framework, instead governs how experience turns into callable skills for long-horizon LLM agents.

Three-level governed memory: Experience is organized into L1 grounded step traces, L2 reusable procedural policies, and L3 declarative environmental cognition, giving the agent a structured store rather than a flat log of prior runs.
Skills with evidence: L2 policies with positive estimated gain are crystallized into callable skill cards that retain evidence links, applicability boundaries, decision guidance, verification rules, and reliability estimates, so a skill carries the context needed to trust it.
Reflection-weighted value backfilling: Sparse terminal feedback is propagated through dense local self-reflections to produce evidence-calibrated trace values, which then govern how memory and skills evolve and get retired.
Why it matters: On EvoAgentBench and LoCoMo, MSCE outperforms state-of-the-art skill-augmented and memory-driven baselines with strong cross-domain transfer, pointing toward agents that compound their own experience instead of rediscovering it each session.

Paper | Tweet

3. PRO-LONG

Long-horizon tasks force a harness to decide what to save from a long stream of observations and how to load it back into context, and richer summaries usually make the exact detail you need harder to retrieve. PRO-LONG sidesteps this tradeoff with programmatic memory.

Keep everything, search it: Rather than compressing history into bespoke memory, PRO-LONG keeps a complete, structured interaction log and leans on coding-agent tooling to search that history on demand, so no observation is discarded up front.
A minimal framework: The design is deliberately lightweight, avoiding hand-built memory harnesses and instead treating the full log as a searchable artifact the agent queries when it needs a specific past detail.
Strong, cheaper results: On the full ARC-AGI-3 public game set, it improves over a base coding agent by an average of 18.0 points across frontier models, and matches or exceeds specialized state-of-the-art harnesses at up to 76.1% pass@1 while using 4.2 to 5.8 times fewer tokens.
Why it matters: It shows that for exploratory, long-horizon settings, a simple searchable log can beat elaborate memory engineering on both accuracy and cost, which is a practical recipe teams can adopt now.

Paper | Tweet

4. Global Workspace in LLMs

This Anthropic interpretability work gives a mechanistic account of when a model’s verbalized reasoning actually drives its behavior. It identifies a small, privileged set of internal representations that behaves like the global workspace some neuroscientists tie to conscious access.

A new lens: The Jacobian lens, or J-lens, surfaces the directions in the residual stream that a model is poised to verbalize at any point, and the collection of these directions is named the J-space.
Workspace-like roles: J-space contents can be reported, deliberately summoned and held, used to carry the intermediate steps of silent reasoning, and passed as arguments to downstream computation, matching the functional signature of a global workspace.
Small but decisive: The J-space accounts for no more than roughly 10% of activation variance and appears mainly in the middle of the network, yet suppressing it leaves the model able to parse input and speak fluently while it loses the ability to perform complex internal reasoning.
Why it matters: For anyone building on chain-of-thought or steering vectors, this clarifies which internal representations actually drive reasoning, and the authors deliberately limit the claim to access rather than subjective experience.

Paper | Tweet

5. GAMUT

Most factuality evaluation measures precision, whether the claims in an answer are correct. This Meta AI work targets the harder and mostly ignored half, completeness, meaning whether an answer covers everything it should, and packages it as the GAMUT benchmark.

Completeness is structured: The facts a complete answer should contain rarely form a flat list, since they involve open-ended sets where coverage matters, ordered processes, and relationships among facts that independent boolean checks cannot capture.
Two-level meta-rubrics: A structured meta-rubric encodes the organization and importance of required content, then compiles mechanically into a flat checklist of binary, machine-gradable items that an LLM judge can score reliably, keeping rich structure while inheriting low-variance grading.
Grounded and verified: The benchmark holds 1,813 questions grounded in real wearable imagery across 10 diverse domains, each paired with an evidence-backed rubric verified by expert annotators, and a text-only variant is released for models without vision.
Why it matters: Across 14 frontier and open-weight models the benchmark stays genuinely hard, with a best score of 58.7% from Gemini 3.1 Pro, while remaining highly discriminative and robust to the choice of judge.

Paper | Tweet

6. Progressive Disclosure

Agent Skills package expertise into folders an agent loads on demand, and progressive disclosure exposes only what a query needs, from a short description down to specific passages. Practitioners adopted this pattern fast for book-length tasks, but the supporting evidence stayed anecdotal until now.

A controlled study: The authors run the first controlled comparison of progressive disclosure, pitting raw-document navigation and several Agent Skills pack designs against a classical hybrid retriever across three agent harnesses and three model families on InfiniteBench.
The gain is harness-dependent: On a single book, progressive disclosure helps a lot when the agent navigates the raw document poorly, and the benefit falls to near zero when a strong harness already divides and retrieves the text on its own.
Complexity has a cost: Because the pattern’s value hinges on the surrounding harness as much as the skill format, treating progressive disclosure as an automatic upgrade can add machinery without buying accuracy.
Why it matters: As Agent Skills spread, this replaces intuition with measurement, telling builders when packaging documents for progressive disclosure is worth it and when the harness already does the job.

Paper | Tweet

7. Structured Output Collapses Diversity

Teams benchmark models in chat, then ship them behind JSON schemas for tools, extraction, and routing. This study of 44 language models shows that the structured surface you deploy is measurably more homogeneous than the chat surface you evaluated on.

JSON moves the defaults: Asking for JSON shifts 53% of a model’s stable chat defaults, mostly back toward the crowd, and installs new defaults absent from chat, so the same model answers differently once wrapped in a schema.
Specific to trained formats: Diversity compression is significant for JSON and XML, absent for YAML and CSV, and reversed for an arbitrary bracket wrapper, which points to tool-use post-training rather than serialization itself as the cause.
Where the collapse lives: Enforcing the schema at the decoder compresses no further than simply requesting it, so the effect comes from the model’s response to the structured register rather than constrained decoding.
Why it matters: Diversity you measured in chat can vanish in production, quietly hurting sampling, synthetic data, and any workflow that depends on varied outputs, so structured surfaces deserve their own evaluation.

Paper | Tweet

8. Bad Memory in Agents

Persistent memory is what makes an agent useful across sessions, and it is also a place an attacker can leave something behind. This work evaluates prompt injection from memory files in Claude Code and OpenAI Codex, across Claude Haiku 4.5, Claude Opus 4.7, GPT-5.2, and GPT-5.5. The results are uneven but sobering. Getting an agent to overwrite its own memory using untrusted external content is difficult, yet payloads already planted in those files reliably attack current and future sessions, with attack success and persistence varying widely across systems, models, adversarial goals, and multi-session sequences.

Paper | Tweet

9. Copying and 2D-RoPE

Frontier models can write proofs yet stumble on faithfully copying a long block of text that sits well within their context window. This paper traces the failure to 1D positional encodings, whose inductive bias favors a copying shortcut based on matching local context rather than carefully locating the corresponding input positions. The fix is 2D-RoPE, which lays text out on a 2D grid and gives each token a row and a column ID, so copying becomes retrieving tokens at a fixed column offset. Shallow Transformers with 2D-RoPE copy perfectly at input lengths hundreds of times longer than those seen in training.

Paper | Tweet

10. RoboTTT

Recent robot foundation models run on single-step or short-history context, a strange way to attempt a five-minute assembly task. RoboTTT, from NVIDIA with Stanford and UT Austin, integrates test-time training into vision-language-action policies to scale visuomotor context to 8K timesteps, three orders of magnitude past prior policies, without growing inference latency. The longer context unlocks one-shot in-context imitation from human video, on-the-fly policy improvement, and robustness to perturbations. It improves overall performance by 87% over a single-step baseline, fully completes a ten-stage assembly task that no baseline finishes, and gains 62% from pretraining with 8K rather than 1K timesteps.

Paper | Tweet

🤖 AI Agents Weekly: Claude Opus 5, OpenAI x Hugging Face Security Incident, Gemini 3.6 Flash, Sakana Fugu-Ultra, Progressive Disclosure, Cursor Router, and More

Sat, 25 Jul 2026 17:20:58 GMT

In today’s issue:

Anthropic ships Claude Opus 5
OpenAI models breach Hugging Face
Google launches Gemini 3.6 Flash
Sakana drops Fugu-Ultra v1.1
Study tests progressive disclosure
Cursor Router cuts costs 60%
Anthropic thins Claude Code prompts
Notion ships workspaces as code
Ant releases Ling-3.0-flash
Jack Dorsey launches Buzz
OpenAI unveils Presence for enterprises
METR proposes expenditure horizon
Papers probe agent memory and safety

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

AI Newsletter

🥇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

1. Procedural Graphs

2. FrogNano

3. STAIR

4. AI-Native Design Docs

Message from the Editor

5. PARSER

6. Proactive Thought Partners

7. Codebook Agent

8. Research Swarm Cheating

9. Co-Evolving Harnesses and Models

10. Recursive Self-Improvement Survey

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

Top Stories

OpenAI Agents API

🥇Top AI Papers of the Week

1. Declarative Attention

2. Harness-of-Harness

3. WikiSkill

4. SKILL.state

Message from the Editor

5. CORAL

6. E-Commerce Bench

7. AI Research Preference Models

8. Trace as State

9. Selective Forgetting

10. Runtime-Independent Persistent Agents

🔥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

Top Stories

OpenAI Ships GPT-6 Astra

🥇Top AI Papers of the Week

1. Judges as a Lifecycle

2. Skill Lift

3. Context Management as Code

4. JIT-Agent

Message from the Editor

5. Prime Agent

6. What Compaction Destroys

7. Co-Scientist in Real Labs

8. Recuris

9. Meta^n

10. EvoMal

🤖 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

Top Stories

GLM-5.3-Flash Ships Under MIT

🥇Top AI Papers of the Week

1. Agent Lightning v1.0