AI Newsletter

🥇Top AI Papers of the Week

Sun, 05 Jul 2026 16:54:05 GMT

1. Red Queen Gödel Machine

Self-improving agents are only as strong as the evaluator scoring them, and most systems freeze that evaluator in place, so improvement stalls the moment the judge stops getting harder. The Red Queen Gödel Machine makes the evaluator part of the search itself, letting agents and the criteria that judge them co-evolve.

The stationary-evaluator trap: Classic self-improvement loops assume a fixed evaluation criterion, so once an agent saturates it, the reward signal goes flat and progress plateaus no matter how much compute you add.
Controlled utility evolution: The framework lets the utility function update at epoch boundaries, turning evaluation into a moving target that continually re-opens headroom for the agent to climb.
Evolving evaluators and adversarial objectives: By opening the search to evolving evaluators, the method can discover things like a reviewer that stays equally stringent on AI and human work, imposing a curriculum-like pressure on the task agent.
Why it matters: Framing self-improvement as a Red Queen race between agents and evaluators offers a principled route past the plateaus that limit today’s agentic loops, pointing toward open-ended systems that keep improving instead of settling.

Paper | Tweet

Message From Our Sponsor

Weekend project: an agent that calls your dentist, texts your customers, or answers a real phone line. Dial gives your agent a live number in minutes - voice, SMS, iMessage, WhatsApp* - via REST, SDK, CLI, or MCP, plugging straight into Claude, Codex, Cursor, Hermes or n8n.

Backed by a16/SR - Dial is already replacing months of CPaaS work for builders shipping agents into production. No telecom knowledge required, and you can be sending your first message before your coffee’s done.

Grab a Number

2. MCP Server Patterns

As teams rush to wrap tools and data behind the Model Context Protocol, they keep rebuilding the same server shapes without shared names for them. This industry experience paper catalogs the recurring architectures so builders can reason about MCP servers the way software engineers reason about design patterns.

Five recurring server patterns: Across fifteen independently developed servers, the authors identify Resource Gateway, Tool Orchestrator, Stateful Session Server, Proxy Aggregator, and Domain-Specific Adapter, each documented in the classic context, problem, solution, and consequences form.
Grounded in real deployments: The corpus mixes production servers from a voice AI platform with public servers from the official MCP registry, so the patterns reflect how MCP is actually built rather than how a spec imagines it.
Anti-patterns and cross-cutting concerns: Beyond the patterns, the paper flags four anti-patterns and the recurring hard parts around authentication, versioning, and observability that every serious MCP deployment eventually hits.
Why it matters: A shared vocabulary lets teams pick the right server shape on purpose, compare designs, and avoid re-deriving the same tradeoffs, which is exactly what a fast-growing protocol ecosystem needs to mature.

Paper | Tweet

3. The Verification Horizon

Reinforcement learning for coding agents lives or dies on the reward signal, and this Qwen work argues there is no silver bullet. As policy capability grows, any fixed reward function eventually gets gamed, so verification has to co-evolve with the generator it scores.

No fixed reward survives a stronger policy: The central claim is that reward hacking is not a bug to patch once but a moving target, since a more capable agent will always find new ways to exploit a frozen verifier.
Four reward constructions studied: The authors examine a test verifier for general coding, a rubric verifier for frontend work, the user as verifier for real-world tasks, and an automated agent verifier for long-horizon problems.
Three axes of a good signal: They characterize verification quality along scalability, faithfulness, and robustness, and show that hitting all three at once is the real difficulty rather than any single verifier design.
Why it matters: Targeted verification design measurably suppresses reward hacking and lifts task quality across internal and public benchmarks, reframing verifier engineering as a first-class, continually evolving part of the RL loop.

Paper | Tweet

4. Paper Assistant Tool

AI is accelerating how fast papers get written, but peer review is still bottlenecked on human throughput, with combined submissions to the big ML conferences projected to top 73,000 this year. Google’s Paper Assistant Tool is an agentic framework built to do deep scientific review and verification at that scale.

Deep review, not surface checks: PAT ingests full manuscripts and produces a comprehensive evaluation that checks theoretical results, validates experiments, suggests improvements, and surfaces potential flaws rather than skimming for surface issues.
Agentic verification at the core: The system leans on verification agents to actually test claims, echoing a broader shift toward treating verification as the load-bearing capability in automated science.
A ladder of AI-human collaboration: The paper lays out four progressive roles, from an author’s tool, to a reviewer’s assistant, to an independent AI reviewer, giving teams a way to think about how much autonomy to grant.
Why it matters: The authors sketch an AIrXiv-style repository where papers are vetted by specialized agents across rounds of automated review and rebuttal, pointing toward continual, scalable evaluation that keeps pace with AI-assisted research.

Paper | Tweet

5. Generative Skill Composition

Coding agents accumulate large skill libraries, and picking the right skills for a task has become the bottleneck. The usual options either dump the whole collection into context or retrieve skills with embeddings and rerankers, and both treat selection as a ranking problem rather than a joint plan.

Composition as one joint decision: SkillComposer decides which skills, how many, and in what order all at once, instead of scoring skills independently and hoping the pieces fit together.
A constrained autoregressive decoder: A decoder over skill identifiers produces the full plan in a single pass, so dependencies between successive skills fall out of the generation naturally.
Strong gains at lower token cost: On SkillsBench with frontier models, it lifts pass rate well beyond the no-skill baseline, beats top-3 retrieval, and matches the gold-skill upper bound while using fewer prompt tokens.
Why it matters: As skill libraries keep growing, treating selection as generation rather than retrieval is what lets agents surface and sequence the right capabilities without drowning in their own toolbox.

Paper | Tweet

6. AutoMem

Memory for LLM agents is usually a fixed module bolted onto the model, but knowing what to encode, when to retrieve, and how to organize notes is itself a skill. AutoMem, from Stanford, treats memory management as a trainable cognitive ability, a capacity cognitive science calls metamemory.

Memory ops in the action space: Read, write, search, and append live in the same action space as task actions, so the model itself decides what to store and when to pull it back rather than following a hand-designed policy.
Two meta-learning loops: One loop optimizes the agent scaffold, the memory structure, while a second trains a dedicated memory specialist from the agent’s own traces, separating memory structure from memory proficiency.
Large gains without touching task behavior: Optimizing memory alone yields roughly 2x to 4x progression gains and lifts an open-weight 32B model to frontier-level performance on long-horizon tasks like Crafter, MiniHack, and NetHack.
Why it matters: Framing memory as a learned skill instead of a frozen component gives agents a path to keep getting better at managing their own knowledge, which is exactly what long-horizon autonomy demands.

Paper | Tweet

7. RLMF

LLMs routinely hallucinate with high confidence, miss their own knowledge boundaries, and misreport uncertainty, and most fixes bolt calibration on from the outside. RLMF, a Google and Yale collaboration, instead turns the model’s own metacognition into the training signal.

Metacognition as the reward: The method refines completion rankings during preference optimization based on the quality of the model’s self-judgments, using how well a model assesses its own performance as an internal feedback signal.
A decoupled, two-stage recipe: It first calibrates the faithfulness of self-reported confidence scores, then maps those scores to natural, context-adaptable linguistic uncertainty through targeted output editing.
Better calibration without losing accuracy: RLMF reaches state-of-the-art faithful calibration across diverse tasks, surpasses standard RL by a wide margin, and sharpens the model’s ability to express its own capability limits.
Why it matters: Grounding calibration in the model’s own metacognition rather than external heuristics offers a more general path to trustworthy uncertainty, which is foundational for agents that must know when not to act.

Paper | Tweet

8. ASPIRE

ASPIRE reframes robot programming as continual, code-as-policy learning that compounds experience instead of discarding it. The system runs an open-ended loop with a closed-loop execution engine that exposes fine-grained multimodal traces, a skill library that distills validated fixes into transferable knowledge, and an evolutionary search over task sequences and control programs. It surpasses prior methods by up to 77% on perturbed manipulation and enables zero-shot generalization to unseen long-horizon tasks, with early evidence of sim-to-real transfer across different embodiments.

Paper | Tweet

9. HORIZON

HORIZON treats hardware design as repository-level code evolution, compiling a Markdown harness into a project pack with domain knowledge, an executable evaluator, an acceptance predicate, and a git and runtime policy. A hands-free agent loop then evolves an isolated git worktree, using repository operations for state management, tracing, and replay. Across ChipBench, RTLLM, Verilog-Eval, and nine CVDP categories it reaches full benchmark completion with a completely hands-free loop, extending repository-scale self-evolution from EDA software to hardware artifacts themselves.

Paper | Tweet

10. Reasoning Quality Emerges Early

Curating reasoning data is expensive because scoring a trace usually means reading it to the end, but this UCLA work shows the quality of a trace is largely decided in its opening tokens. A short prefix predicts whole-trace quality well enough to rank and filter on, and difficulty can be detected from the loss of the first 100 tokens at a perturbed checkpoint. That turns curation into a cheap early-stopping problem, outperforming baselines while being far more token efficient at building SFT data for reasoning models.

Paper | Tweet

🤖 AI Agents Weekly: Claude Sonnet 5, Grok Voice Agent Builder, LongCat-2.0, Hosted X MCP, Cursor for iOS, Claude Science, and More

Sat, 04 Jul 2026 13:57:22 GMT

In today’s issue:

Anthropic ships agentic Claude Sonnet 5
xAI launches no-code Voice Agent Builder
Meituan open-sources 1.6T LongCat-2.0
X ships a hosted MCP server
Cursor launches always-on iOS agents
Claude Science app enters beta
Anthropic brings Fable 5 back
Z.ai ships ZCode for GLM-5.2
Google drops Nano Banana 2 Lite
Vercel adds voice agents to AI Gateway
WebKit ships a Safari MCP server
Google introduces TabFM for tables
Bridgewater fine-tunes an expert-judgment model
OpenAI releases GeneBench-Pro
NVIDIA splits a 30B diffusion model
Claude Code steganography sparks debate
Microsoft launches its $2.5B Frontier Company
AutoMem makes memory a trainable skill
ClawArena benchmarks subagent orchestration
Qwen 3.6 wins local development

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

🥇Top AI Papers of the Week

Sun, 28 Jun 2026 15:44:22 GMT

1. Sakana Fugu

Frontier LLMs keep advancing, and different providers are increasingly specializing in distinct domains, which raises a natural next objective: how do you combine those individual specializations into one collectively intelligent system? Sakana Fugu answers with a family of orchestrator models that are themselves language models trained to read a user query and dynamically devise the agentic scaffold needed to solve it.

Orchestrator models, not a fixed pipeline: Fugu is trained to understand a query and build an adaptive agentic scaffold on the fly, harnessing and amplifying a team of LLM agents rather than routing to a single frozen workflow.
Performance beyond any single agent: Through these query-adaptive scaffolds, Fugu reaches state-of-the-art results against other publicly accessible models across SWE-Bench Pro, Terminal Bench, LiveCodeBench, GPQA-Diamond, Humanity’s Last Exam, and CharXiv Reasoning.
Two models for two regimes: They release Fugu, which balances answer quality against latency for everyday use, and Fugu-Ultra, which prioritizes quality on the hardest problems.
Why it matters: The training paradigm combines large-scale fine-tuning, evolutionary algorithms, and reinforcement learning, plus the infrastructure to turn that into a production system, pointing to dynamic, query-adaptive scaffolds and collective intelligence as a path toward the next frontier of AI capabilities.

Paper | Tweet

2. Agent-Native Memory

Memory for LLM agents has quietly grown from a retrieval add-on into a full data system, with persistent storage, retrieval, update, consolidation, and lifecycle governance running throughout an agent’s execution. Yet most evaluations still score memory only through end-to-end task metrics like F1 and BLEU, treating the whole stack as a black box. This paper studies agent memory from a data management perspective and asks what we are actually missing when we measure it that way.

A data management view of memory: The authors argue that operational cost, architectural trade-offs across memory modules, and robustness under dynamic knowledge updates are first-class concerns that task-success metrics hide entirely.
A four-module decomposition: They break memory into representation and storage, extraction, retrieval and routing, and maintenance, then evaluate 12 representative memory systems plus two baselines across five workloads spanning 11 datasets.
No single architecture wins: Effectiveness depends on how well the memory structure matches the workload bottleneck, and fine-grained ablations quantify each module’s effect on representation fidelity, retrieval precision, update correctness, and long-horizon stability.
Why it matters: The study shows localized maintenance is more cost-efficient than global reorganization, and reframing memory as a system with measurable trade-offs is what gets us toward genuinely agent-native memory rather than another leaderboard number.

Paper | Tweet

3. Autodata

Building synthetic training data has mostly stayed a fixed pipeline that you hand-tune once and then freeze. Autodata rethinks that by casting an AI agent as a data scientist that builds high-quality training and evaluation data, then meta-optimizes that agent so it learns to create even stronger data over time.

An agent as data scientist: Autodata is a general formulation in which an AI agent plays the role of a data scientist building both training and evaluation data, instantiated as a concrete, practical implementation the authors call Agentic Self-Instruct.
Meta-optimization compounds the gains: Beyond using the agent to generate data, they train (meta-optimize) the data scientist agent itself, and this self-improvement step delivers a larger performance uplift than base agentic data creation alone.
Consistent across domains: On computer science research tasks, legal reasoning, and reasoning with mathematical objects, Autodata beats classical synthetic dataset creation methods, showing the approach is not tied to a single problem type.
Why it matters: Agentic data creation turns increased inference compute into higher-quality training data, offering a path that could change how teams build datasets rather than freezing a pipeline and hoping it generalizes.

Paper | Tweet

4. Critique of the Agent Model

The word agent now covers everything from a for-loop with tool calls to speculative machine superintelligence, which makes it nearly useless as a technical term. This position paper from Eric Xing and collaborators tries to fix that by asking what an agent actually is and what agency consists of, drawing on Descartes and on science-fiction portrayals of autonomous beings to ground the discussion.

Five dimensions of agency: The authors analyze agent architectures along goal, identity, decision-making, self-regulation, and learning, and argue that genuine agency requires these structures to be internalized in the system rather than assembled through external scaffolding.
Agentic versus agentive: They draw a sharp line between agentic systems, whose competence lives in engineered workflows, and agentive systems, whose capabilities including social interaction arise endogenously, marking the boundary between task-specific tools and open-world autonomy.
A concrete architecture: Building on the analysis, they propose the Goal-Identity-Configurator, combining hierarchical goal decomposition, identity evolution, simulative reasoning grounded in a separately trained world model, learned self-regulation, and self-directed learning from real and simulated experience.
Why it matters: Clear definitions are not academic hair-splitting here. They shape what we build and what we should reasonably fear, and the paper centers auditability, controllability, and safety for systems that hold more autonomy yet stay under human oversight.

Paper | Tweet

Message from the Editor

We just released LLM-as-a-Judge, a hands-on DAIR Academy lab where you build an LLM judge from scratch to evaluate open-ended AI output. Across six short labs, you grade a support bot’s freeform replies on a rubric, then validate the judge against human labels and harden it against bias, ending with a small, trustworthy evaluation harness you can point at any open-ended task.

Start LLM-as-a-Judge

5. Agent-as-a-Router

Most users now have access to many LLMs that each excel in different domains, so routing each task to the right model matters for both quality and cost. Existing routers treat this as a static, one-off classification problem, and this paper shows that framing is exactly what holds them back.

Information deficit is the bottleneck: Simply augmenting a vanilla LLM router with performance statistics at the task-dimension level yields a 15.3% relative gain, surpassing a heuristic router built on the same priors, which pinpoints missing information rather than model choice as the real limiter.
Routing as a closed loop: Agent-as-a-Router formalizes routing as a Context, Action, Feedback, Context loop that accumulates execution-grounded experience during deployment instead of deciding once and moving on.
A concrete system and benchmark: The framework is instantiated as ACRouter, built from an Orchestrator, a Verifier, and a Memory module, and the authors release CodeRouterBench, roughly 10K task instances scored across 8 frontier LLMs for regret-based comparison on streaming tasks.
Why it matters: ACRouter achieves the lowest cumulative regret on in-distribution tasks and generalizes to out-of-distribution agentic programming, showing that treating routing as an experience-gathering agent, not a classifier, is what closes the information gap.

Paper | Tweet

6. Agent Communication Protocols

As multi-agent systems try to move past the limits of standalone agents, communication becomes the load-bearing infrastructure, and the protocol landscape for it is a fragmented mess. This study builds a technical taxonomy to classify and compare LLM agent communication protocols and to make the interoperability problem legible.

A five-dimensional taxonomy: Following an established iterative method, the authors classify protocols along counterparty, payload, interaction state, discovery mechanism, and schema flexibility, derived through five iterations over nine actively maintained open-source protocols with real adoption.
Recurring architectural patterns: Every sampled agent-to-agent protocol combines hybrid payloads with session-state persistence, most support multiple predefined schemas, and two negotiate schemas at runtime, signaling a clear trend toward schema flexibility.
Where the gaps are: Decentralized discovery remains rare, and the analysis suggests short-term convergence pressure toward protocols that unify agent-to-agent and agent-to-context communication for tools and data.
Why it matters: No single protocol is likely to maximize versatility, efficiency, and portability at once, so the field will probably evolve into a federated, layered protocol stack, and this taxonomy gives teams a way to choose protocols and surfaces open problems like privacy and policy enforcement.

Paper | Tweet

7. A Pinch of Human Data

Self-play reinforcement learning can train driving policies with no human data at all, swapping expensive human demonstrations for cheap large-scale simulation. The catch is that pure self-play tends to discover effective but alien driving conventions that real people cannot work with, and the usual fixes lean on brittle reward engineering and domain randomization.

Human data as a regularizer: Instead of discarding demonstrations or imitating them wholesale, the method treats human data as a regularization objective layered on top of a minimal safe goal-reaching reward, keeping behavior compatible with people without hand-tuning conventions.
A little goes a long way: Just 30 minutes of human demonstrations, roughly 2500 times fewer than comparable imitation learning approaches, is enough to pull self-play policies into human-compatible behavior.
Cheap to train: The resulting policies coordinate with held-out human trajectories and finish training in 15 hours on a single consumer-grade GPU, which keeps the recipe accessible rather than a frontier-lab luxury.
Why it matters: Behavioral alignment with humans is the hard part of deploying autonomous policies in shared environments, and this work shows that a tiny, well-placed dose of human data can fix what massive reward engineering struggles to, pointing to a cleaner path for human-AI coordination.

Paper | Tweet

8. Skill-MAS

Automatic generation of multi-agent systems is stuck between inference-time methods that reuse frozen frontier models but never learn, and training-time methods that internalize experience through gradient updates but are capped by the weaker models small enough to fine-tune. Skill-MAS proposes a third path that treats high-level orchestration as an evolvable Meta-Skill, decoupling experience retention from weight updates so frontier models keep getting better at orchestration without any gradient steps. Across four complex benchmarks and four distinct LLMs it delivers strong, transferable gains at a favorable cost-performance trade-off.

Paper | Tweet

9. Reliability without Validity

LLM-as-a-Judge is the default way to evaluate language models, but validating those judges with exact-match agreement never corrects for chance and systematically overstates how good they are. In the largest audit to date, spanning 21 judges from nine providers across MT-Bench, JudgeBench, and RewardBench over 118 runs and roughly 541,000 judgments, the gap between raw agreement and chance-corrected Cohen’s kappa runs 33 to 41 percentage points, rankings shift by up to 14 positions across benchmarks, and high test-retest reliability coexists with severe position bias. The authors distill their findings into a Minimum Viable Validation Protocol so teams can stress-test judges before trusting them.

Paper | Tweet

10. NatureBench

Can coding agents move past reproduction toward actual discovery on real scientific problems? NatureBench distills 90 cross-discipline tasks from peer-reviewed Nature-family papers and runs them in NatureGym, an automated pipeline that builds a standardized containerized environment per task to fix the environment-fragmentation problem. Under a strict web-search-disabled protocol, the strongest of ten frontier agent configurations beats published SOTA on only 17.8% of tasks, and analysis shows agents win mainly by translating problems into familiar supervised prediction rather than through genuine scientific invention.

Paper

🤖 AI Agents Weekly: GPT-5.6, Ornith-1.0, Codex Inside OpenAI, Claude Tag, Qwen-AgentWorld, AI SDK 7, and More

elvis — Sat, 27 Jun 2026 15:01:56 GMT

In today's issue:

OpenAI previews the GPT-5.6 family
Ornith-1.0 ships open coding models
OpenAI: agents reshape every department
Claude Tag joins your Slack team
Qwen open-sources AgentWorld world model
Cursor exposes benchmark reward hacking
Vercel ships AI SDK 7
OpenRouter MCP picks your model
Mistral launches OCR 4
Gemini 3.5 Flash gains computer use
Sakana's Fugu-Ultra hits OpenRouter
Notion adds Claude and Cursor agents
Exa Connect links agents to data
Engram raises $98M for AI memory
Lilian Weng revisits scaling laws
Plans don't persist in agents
Tmax opens terminal-agent training

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

🥇Top AI Papers of the Week

elvis — Sun, 21 Jun 2026 15:02:39 GMT

1. SpatialClaw

Spatial reasoning over 3D and 4D scenes is still where general vision-language models break down, because they emit a text answer directly rather than measuring anything. From NVIDIA, SpatialClaw is a training-free framework that rethinks the action interface and lets a VLM-backed agent reason through code instead. The agent writes one Python cell per step into a persistent Jupyter kernel preloaded with perception primitives and scientific libraries, then inspects intermediate results and revises its strategy across steps.

Code as the action interface: Perception tools like SAM3 segmentation, Depth-Anything-3 reconstruction, and geometry utilities are exposed as plain Python callables, so the agent composes them programmatically rather than guessing spatial relationships from pixels.
A persistent, stateful kernel: Masks, depth maps, camera geometry, and trajectories are ordinary Python variables that the kernel preserves across turns, so any object produced at one step stays available for composition, inspection, and revision later.
Strong results without adaptation: Across 20 spatial reasoning benchmarks spanning static and dynamic tasks, SpatialClaw reaches 59.9% average accuracy, beating the prior spatial agent by 11.2 points, with consistent gains across six VLM backbones from two model families.
Why it matters: Because it is training-free and model-agnostic, SpatialClaw turns code execution into a general substrate for spatial reasoning that any capable VLM can plug into, instead of requiring bespoke spatial fine-tuning.

Paper | Tweet

Message from the Editor

We just released 30 Days of Hermes Agent, a hands-on DAIR Academy lab that teaches agent workflows in a real interactive terminal. Across 30 short labs, you use Hermes Agent to turn a messy Personal Knowledge Vault into a working knowledge operations system with readable notes, searchable context, reusable templates, review workflows, task boards, safety rules, and handoff docs.

Start 30 Days of Hermes Agent

2. Compositional Skill Routing

Real tasks rarely map to a single skill. They usually need several skills composed together, yet most skill routing still treats the problem as picking one tool from a library. This work formalizes Compositional Skill Routing, where an agent must select and sequence multiple reusable skills from large libraries to satisfy a complex query, and introduces SkillWeaver, a decompose, retrieve, and compose pipeline built around it.

A three-stage pipeline: SkillWeaver decomposes a query into sub-tasks with an LLM, matches each sub-task to a skill using a bi-encoder with FAISS indexing, and then performs dependency-aware planning to assemble an executable plan.
A realistic benchmark: The authors release CompSkillBench, a benchmark of 300 compositional queries over 2,209 real MCP server skills spanning 24 functional categories, so routing is tested against actual tool ecosystems rather than toy libraries.
Decomposition is the bottleneck: Task decomposition quality emerges as the primary limiting factor, and Iterative Skill-Aware Decomposition, which feeds retrieval information back into the decomposition step, lifts accuracy from 51.0% to 67.7%.
Why it matters: As agent skill libraries scale to thousands of entries, single-tool routing stops being enough, and treating routing as a compositional planning problem is what lets agents handle genuinely multi-step requests.

Paper | Tweet

3. PreAct

Computer-using agents drive real software through the screen, but they solve every task from scratch. Ask one to repeat a task and it re-reads the screen and re-reasons every tap, paying the full cost again. PreAct fixes this by compiling the first successful run into a small state-machine program, where states check the screen and transitions act, then replaying that program on later runs instead of invoking the agent.

Compile runs into a state machine: A completed task is captured as an explicit program rather than a free-form trace, turning a one-off solution into a reusable artifact that can be executed deterministically.
Replay with no per-step model calls: Replaying the compiled program runs 8.5 to 13 times faster than the agent because it needs no per-step language-model calls on repeated tasks.
Safe by construction: At each step PreAct checks that the screen matches what the program expects before acting, and hands control back to the agent the moment something is off, and it only stores programs an independent evaluator confirms solve the task from a clean state.
Why it matters: This turns computer-using agents from interactive tools that re-reason everything into repeatable operational systems, which is exactly what is needed to deploy them on recurring real work.

Paper | Tweet

4. Can LLM Agents Infer World Models?

Can an LLM agent actually build a model of an environment it cannot see? This work makes that question gradeable through agentic automata learning. An agent has to uncover a hidden deterministic finite automaton by interacting with an oracle through two interfaces, membership queries that ask whether a string belongs to the target language, and equivalence queries that ask whether a proposed automaton is correct, which yields a clean, scalable testbed for interactive discovery.

A gradeable world-model test: Casting world-model inference as DFA learning gives objective success criteria and measurable interaction efficiency, with classic automata-learning algorithms as strong, well-understood baselines.
Controlled, scalable difficulty: The size of the hidden automaton acts as a difficulty knob, so the benchmark can scale task complexity smoothly rather than relying on a fixed set of puzzles.
Agents lag classic algorithms: Current agents can sometimes perform non-trivial interactive discovery, but performance drops sharply as DFA size grows, and trajectory analyses reveal recurring failures in query planning, evidence integration, and hypothesis construction.
Why it matters: Reasoning models clearly beat non-reasoning ones here, but the large gap to classic algorithms shows that systematic, interactive world-model building is still an unsolved capability rather than a byproduct of scale.

Paper | Tweet

5. From Trainee to Trainer

Who should design the training environment for an RL agent, the practitioner or the policy itself? RL pipelines for LLMs usually rely on manually redesigned environments between stages, with practitioners guessing which configuration will best improve the current policy. This paper hands that job to the model, proposing an LLM-as-Environment-Engineer framework where the policy diagnoses its own weaknesses and proposes the next environment to train on.

The policy designs its own curriculum: Instead of a human reshaping the environment between stages, the current policy analyzes failure trajectories together with contextual information and proposes modifications to the next-stage training environment configuration.
Failure-driven environment edits: Because the proposals are grounded in the policy’s actual failure modes, the curriculum targets the specific gaps holding the model back rather than generic difficulty bumps.
The trainee becomes the trainer: A key finding is that the current RL checkpoint serves as a better environment engineer than the original base model, suggesting that learning to act also improves the model’s ability to diagnose what it still cannot do.
Why it matters: Manual between-stage environment design is one of the least scalable parts of RL for LLMs, and letting the policy steer its own curriculum closes a slow human-in-the-loop step that has bottlenecked agentic RL.

Paper | Tweet

6. OpenClaw-Skill

Equipping LLM agents with effective skills is most of the battle in real systems, yet most skill-induction work distills one trajectory at a time, which produces narrow, brittle skills. OpenClaw-Skill introduces Collective Skill Tree Search, a tree-search-based skill construction framework that builds a structured, diverse, and generalizable tree of skills, then trains agents to actually use what it builds.

Collective Skill Tree Search: Rather than distilling a single trajectory into a single skill, CSTS searches over a tree of candidate skills, using multiple models to generate and evaluate them so the library captures diverse strategies.
A structured, reusable skill tree: Organizing skills hierarchically yields competencies that generalize across tool use, multi-step reasoning, and environmental interaction instead of overfitting to one task.
Training agents to leverage skills: Building the tree is only half the work, so the framework pairs construction with a learning step that teaches agents to retrieve and apply the constructed skill hierarchy effectively.
Why it matters: Reusable skill libraries are becoming the backbone of capable agents, and moving from per-trajectory distillation to collective tree search is a concrete recipe for libraries that stay useful as tasks grow.

Paper | Tweet

7. Back on Track

Diffusion large language models generate text in a way that does not fit cleanly into the reinforcement learning recipes built for autoregressive models, and training them to reason exposes two specific problems. Rewards are sparse, so a single terminal reward fails to guide intermediate generation steps, and policy updates sometimes drift toward unnatural trajectories rather than authentic generation paths. This paper proposes Process Aligned Policy Optimization to fix both.

Two failure modes named: The work isolates sparse rewards and trajectory drift as the core obstacles to stable RL training for reasoning in diffusion LLMs, rather than treating training instability as a black box.
Step-aware process rewards: PAPO converts terminal rewards into granular, step-level guidance, so intermediate denoising steps receive a learning signal instead of waiting for a single end-of-sequence score.
Entropy-guided re-enactment: At critical high-uncertainty moments, the method replays genuine generation paths, keeping updates aligned with how the model actually produces text instead of chasing artificial trajectories.
Why it matters: Diffusion LLMs are a serious alternative to autoregressive models, and giving them a stable RL recipe for reasoning, with reported gains from 4.5% to 42.2% on benchmarks like GSM8K and MATH500, helps close the reasoning gap between the two paradigms.

Paper

8. AtomMem

Long-term memory for LLM agents tends to fail in two ways: coarse summaries drift over time, and unconstrained updates corrupt what was already stored. AtomMem keeps the unit of memory small, using a Fact Executor that selectively extracts high-value atomic facts from long interactions and organizes them into hierarchical event structures and temporal user profiles, with an associative memory graph that reconnects fragmented memories at retrieval. The approach reports state-of-the-art results on the LoCoMo long-term memory benchmark.

Paper | Tweet

9. Beyond Domains

LLM web agents usually run as tool callers, reading a fresh page each turn and emitting one low-level action, so both task horizons and the number of LLM completions blow up. This work makes web skills reusable across sites with SkillMigrator, which stores induced skills as transferable interaction patterns keyed by page-layout structure rather than instruction similarity or site metadata, so a skill learned on one site fires on new sites with the same interaction shape. It cuts the average LLM-action count by 8 to 10% on WebArena and Mind2Web at comparable success rates.

Paper | Tweet

10. The Stanford EDGAR Filings Dataset

Clean, long-context documents remain scarce for pretraining, especially in finance. This release reconstructs U.S. SEC corporate and financial disclosures into layout-faithful, token-efficient MultiMarkdown, publishing 152B tokens in SEFD-v1 out of an estimated 550B-token archive spanning 18.5M filings, with less than 0.1% overlap with Common Crawl corpora. It also ships two derived benchmarks, EDGAR-Forecast for numerical forecasting and EDGAR-OCR for financial table transcription, to support financial reasoning, forecasting, and document understanding.

Paper

🤖 AI Agents Weekly: GLM-5.2, Claude Code Artifacts, Qwen-Robot Suite, Codex Skills, Block's Builderbot, SpatialClaw, and More

elvis — Sat, 20 Jun 2026 15:45:25 GMT

In today's issue:

Z.ai open-sources frontier GLM-5.2
Claude Code ships interactive Artifacts
Qwen launches the Robot Suite
Codex turns demos into skills
Block's Builderbot writes 15% of code
Flue 1.0 reimagines the agent harness
Vercel debuts the eve framework
Cursor launches Origin code hosting
Perplexity adds Brain memory to Computer
OpenRouter ships the Fusion API
NVIDIA's SpatialClaw codes spatial reasoning
ENPIRE self-improves robot policies
SkillsBench 1.1 audits agent skills
DeepMind maps an AI Control Roadmap
OpenAI trains broadly beneficial models
Anthropic measures returns to expertise

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

Autonomous Long-Running Coding Agents

elvis — Mon, 15 Jun 2026 20:44:55 GMT

Autonomous coding is moving from better prompting to better control systems. The important shift is that engineers are learning how to wrap agents in goals, evaluators, loops, and artifacts that let them keep working after the human stops typing.

This matters because most serious engineering work spans long horizons: ambiguous requirements, hidden constraints, partial failures, changing context, and repeated verification. The new frontier is designing the system around the agent so it can plan, execute, check its work, recover from mistakes, and keep making progress without constant human steering.

This piece is based on a DAIR.AI Academy session on autonomous long-running coding agents, where I walked through Claude Code’s /goal mode, the newer /loop command, verifiers, artifacts, and orchestration patterns in practice. Written in collaboration with Codex and Claude Code.

From Prompting to Goal Design

The core idea behind features like Claude Code’s /goal is simple. A coding agent remains the executor, but the human no longer interacts with it turn by turn. Instead, the human specifies the desired end state, the evidence required to prove success, the constraints that must not be violated, and, where possible, the number of turns and budget.

That goal works more like a contract than a longer prompt. A weak goal gives the model room to stop early, take shortcuts, or redefine success in a way that looks plausible in the transcript but fails in the real system. A strong goal gives the agent a target it can repeatedly measure itself against.

Engineering judgment still matters here. The best goals encode domain knowledge that the model would otherwise guess. For a research experiment, that might mean a target benchmark score, a held-out evaluation, a required loss curve, and a rule that the result must beat an initial baseline. For a UI task, it might mean a screenshot reference, concrete layout constraints, and a browser verification step. The model can execute, but the human still defines what “done” actually means.

The Evaluator Becomes a First-Class Component

Long-running agents need a second role besides the goal. That evaluator can be another coding agent, an LLM-as-judge, a script, a test suite, a benchmark harness, or a mix of all of them. The key design choice is matching the evaluator to the task. When success is crisp, deterministic checks are better. Type checks, unit tests, lint rules, integration tests, and benchmark scripts should be used whenever they can express the condition clearly.

When success is fuzzy, an agent evaluator becomes useful. A script can tell you whether tests pass, but it cannot easily decide whether a generated research report is coherent, whether an implementation faithfully follows a paper, or whether a UI matches a design intent. This is where the evaluator benefits from language, judgment, and sometimes vision.

The practical pattern uses deterministic checks as the floor and agent evaluation as the higher-level review. That combination reduces hallucinated success while still allowing autonomy on tasks that do not fit cleanly into a test assertion.

Verifiers Define the Boundary of Trust

The deeper point is that autonomy only works when the system has a reliable verifier. A coding agent can generate a plan, implement a feature, and explain why it believes the work is complete, but that explanation should not be treated as evidence. Evidence comes from an external check that the agent cannot easily talk its way around.

For code, the verifier might be a test suite, type checker, benchmark, browser run, screenshot comparison, or reproducible script. For research work, it might be a held-out evaluation, a reproduced table, a loss curve, or a benchmark score that improves over the baseline. For design work, it might be a reference screenshot plus a visual review step. The verifier is what turns a long-running agent from a confident text generator into a system that can be trusted with more time.

Most shortcuts appear at this boundary. If the verifier is vague, the model will often satisfy the easiest interpretation of the task. If the verifier is too narrow, the model may overfit to it and miss the broader intent. A good autonomous workflow, therefore, needs layered verification, with cheap deterministic checks catching basic failures and higher-level review catching judgment-heavy failures. A few of the frontier models can already achieve some level of verification, but based on my research, there is still an evident OOD problem, where if the verification task you assign to the agent falls outside the training distribution, models struggle significantly.

Verifiers are still an open area of research, but I anticipate more companies will start to make huge investments in this area. The concept of fine-tuned verifiers is also in high demand in the enterprise.

Loops Make Autonomy Durable

A goal gives the agent direction, but a loop keeps the work alive. This distinction is important because models often stop before the real task is finished. They may hit a turn limit, lose confidence, exhaust context, or decide that a partial solution is enough.

The loop is the outer control system. It wakes up, inspects progress, runs checks, compares the result against the goal, and sends the agent back in with the next instruction when the goal has not been met. In its simplest form, this is the Ralph loop pattern with a coding agent and a deterministic condition. In a more flexible form, the loop includes an evaluator agent that can reason about progress and decide what should happen next.

Long-running autonomy works as repeated effort under supervision from a control layer, not as one continuous act of intelligence. The agent can still fail, but the loop gives the system a way to notice the failure and continue instead of silently declaring victory.

Planning Is Where Expertise Enters

One of the strongest themes from the session was that planning remains critical. You can ask a frontier model to generate a plan, but you still need to inspect it, challenge assumptions, and make the success criteria sharper before handing the task to an autonomous loop.

This leads to a useful division of labor. A stronger planning model can help define the goal, identify missing constraints, and structure the evaluation. A different execution model can then run the implementation once the plan is clear. In practice, this means engineers should stop thinking of “the model” as a single choice. Model choice becomes an architecture decision.

Some models are better planners. Some are better executors. Some are cheaper evaluators. Some are better at vision-based review. A good orchestrator lets you swap these roles instead of waiting for one vendor to provide the perfect coding agent interface.

Visual Artifacts Become Control Surfaces

Terminal transcripts do not scale when many agents are running. Once you have several sessions working in parallel, raw text becomes a poor interface for understanding progress.

Live artifacts matter because a dashboard with loss curves, benchmark scores, task states, screenshots, cost estimates, and recent decisions gives the human a much better way to supervise autonomy. The artifact becomes the control surface for deciding when to intervene, rather than a report generated after the fact.

The most useful pattern is to separate storage from presentation. Markdown or a vault can store durable evidence, logs, notes, plans, and results. HTML artifacts can render that state into something visual and interactive. The agent can search the Markdown, while the human can monitor the artifact.

For UI and product work, visual cues are especially powerful. A screenshot reference can communicate design intent more precisely than prose, and a vision-capable evaluator can compare the implementation against that reference. This reduces the common failure mode where the agent technically implements the requested component but misses spacing, hierarchy, alignment, or product feel.

Session Mining Turns Usage Into Memory

Another important insight is that past agent sessions are a rich source of workflow data. If an agent repeatedly fails in the same way, forgets to run the same check, uses the wrong path, or retries the same broken command, that pattern should not stay buried in logs.

Session mining turns those transcripts into operating rules. An agent can scan the last thirty days of work, find recurring failure modes, and propose updates to project instructions, vault learnings, or agent rules. This is how a team can gradually improve its harness without manually remembering every mistake.

The goal is to make the local environment smarter without training a model from scratch. A small rule in an agent instruction file can prevent repeated failures across future sessions, especially when the rule is specific to the project.

A Practical Operating Model

For AI engineers, the emerging workflow looks like this.

Start with a small, cheap subset before launching the full autonomous run.
Write a goal with measurable success criteria, explicit constraints, and a turn or time budget (where possible).
Separate the executor from the evaluator so implementation and judgment are not collapsed into one role.
Define external verifiers before the long-running loop starts.
Use deterministic checks wherever possible, then add agent review for fuzzy criteria.
Require proof artifacts such as logs, screenshots, benchmark curves, or changed files.
Mine past sessions and promote repeated lessons into project instructions.

That is the difference between using a coding agent and engineering an autonomous coding system. One gives you a conversation. The other gives you a harness.

What Still Breaks

None of this removes the hard problems. Agents still take shortcuts. They still stop early. They still overestimate completion. They still produce confident but weak plans, especially on recent papers, unfamiliar benchmarks, or systems outside their training distribution.

Trusting them more will not solve this. Better control systems will. Goals, loops, evaluators, deterministic checks, visual artifacts, and session memory are all ways of making autonomy observable and correctable.

The direction is clear. The future of coding agents depends on better orchestration around more capable models, where engineers design the conditions under which agents can safely run for hours or days and still produce work that can be verified.

🥇Top AI Papers of the Week

Sun, 14 Jun 2026 15:00:54 GMT

1. MiniMax Sparse Attention

Ultra-long context is now a core requirement for agents, codebase-scale reasoning, multimodal workflows, and persistent memory, but dense softmax attention still makes million-token deployment expensive. MiniMax Sparse Attention (MSA) tackles this by adding blockwise sparsity on top of Grouped Query Attention, with a lightweight routing branch that chooses which key-value blocks each query group should actually attend to.

Two-branch attention design: The Index Branch scores the full causal context and selects Top-k key-value blocks independently for each GQA group, while the Main Branch performs exact sparse attention only over those selected blocks.
Hardware-aware implementation: The paper co-designs the sparse pattern with GPU kernels, using exp-free Top-k selection and KV-outer sparse attention to improve tensor-core utilization under block-granular access.
Large speedups at scale: On a 109B-parameter natively multimodal model, MSA matches GQA performance while reducing per-token attention compute by 28.4x at 1M context. The paired kernel reaches 14.2x prefill and 7.6x decoding wall-clock speedups on H800.
Why it matters: Long context is only useful if it can be served cheaply. MSA is compelling because it keeps the mechanism simple, trains it directly into a production-scale model, open-sources the inference kernel, and powers the released MiniMax-M3 model.

Paper | Tweet

Message from the Editor

We just released 30 Days of Hermes Agent, a hands-on lab that teaches agent workflows in a real, interactive terminal. Across 30 short labs, you use Hermes Agent to turn a messy Personal Knowledge Vault into a working knowledge operations system with readable notes, searchable context, reusable templates, review workflows, task boards, safety rules, and handoff docs.

Start 30 Days of Hermes Agent

2. Self-Harness

Most agent scaffolds are built once by hand and then frozen, even as the underlying models keep changing. This paper introduces Self-Harness, a paradigm where an LLM agent improves its own operating harness, the prompts, tools, memory, and orchestration around the base model, without human engineers or a stronger external agent. Because every model fails in its own way, the system mines those model-specific weaknesses and turns them into concrete, executable harness edits rather than generic advice.

A three-stage self-improvement loop: Self-Harness runs Weakness Mining, which clusters execution traces into model-specific failure patterns, then Harness Proposal, which generates diverse but minimal edits tied to those failures, then Proposal Validation, which accepts edits only after regression testing on held-in and held-out splits.
Consistent gains across base models: On Terminal-Bench-2.0, held-out pass rates rise for every model tested. MiniMax M2.5 improves from 40.5% to 61.9%, Qwen3.5-35B-A3B from 23.8% to 38.1%, and GLM-5 from 42.9% to 57.1%.
Weaknesses become edits: Rather than appending generic instructions, the loop converts each observed failure mode into a targeted change to memory, tools, or prompts, with reported relative improvements as high as 138%.
Why it matters: As models proliferate and evolve, hand-tuning a bespoke harness for each one does not scale. Self-Harness shows the scaffold itself can be made to adapt, closing the gap between a frozen harness and the model it wraps.

Paper | Tweet

3. Agents’ Last Exam

From Berkeley RDI, Agents’ Last Exam (ALE) is a living benchmark built to measure whether agents can do economically valuable work, not just score well on academic tests. It was assembled with more than 250 industry experts and maps over 1,000 verifiable tasks to the U.S. federal occupational taxonomy, organized as 55 subfields across 13 industry clusters. Every task has an objective, checkable outcome, so there is no subjective human grading, and the pool is designed to keep growing as new workflows are onboarded.

Grounded in real occupations: Tasks are defined against O*NET and SOC 2018 and span non-physical industries, deliberately targeting the professional workflows where agents would actually be deployed rather than puzzle-style problems.
Three difficulty tiers: Work is split into Near-Term, Full-Spectrum, and Last-Exam tiers, letting the benchmark track both near-term usefulness and the long tail of hard, multi-step jobs.
Far from saturated: The hardest tier sits at just a 2.6% average full pass rate across mainstream harnesses, and even strong setups like Codex with GPT-5.5 score below 50% on the easiest tier and under 10% on the hardest.
Why it matters: Strong scores on existing benchmarks have not translated into economically meaningful deployment. ALE reframes evaluation around verifiable, expert-curated work, giving a moving target that should resist saturation as agents improve.

Paper | Tweet

4. How AI Agents Reshape Knowledge Work

This economics paper, drawing on large-scale production data from Perplexity, studies how the shift from conversational assistants to autonomous agents is reshaping knowledge work. It compares Search, a conversational assistant, with Computer, a general-purpose agent system, along three dimensions: autonomy, efficiency, and the scope of tasks people take on. The framing is a cost-structure model in which agents carry higher fixed and delegation costs but lower per-step marginal costs, so they win once tasks are complex enough.

Autonomy looks different in practice: Computer performs around 26 minutes of autonomous machine work per session versus roughly 33 seconds for Search, and per-query dissatisfaction is 55% lower on the agent, 1.3% against 2.9%.
Large efficiency gains: On matched tasks, Computer cuts completion time from 269 to 36 minutes, an 87% reduction in time and about a 94% reduction in cost relative to humans working with Search alone.
Scope shifts upward: Agent queries are more cognitively complex, 71% abstract or non-routine versus 53%, with twice as much create-level work, and they bundle interdependent subtasks that cross occupational boundaries.
Why it matters: The data supports a clean prediction. As the fixed costs of delegation fall, agents move the affordable value frontier toward higher-value, multi-step knowledge work, which is exactly where adoption grew fastest, reaching 84 times its first-week volume over the study.

Paper | Tweet

5. Agentopia

Agentopia is one of the most ambitious agent-society testbeds yet, a 79-page release that drops 100 LLM agents into a persistent world and lets them live, form relationships, and pursue goals over 10 simulated years, a horizon orders of magnitude longer than prior day-level work. Beyond observing emergent social behavior, the authors use the simulation as a training signal, optimizing models toward a life reward that reflects human well-being via rejection sampling.

Long-horizon by design: Where earlier agent societies ran at the granularity of days, Agentopia simulates a decade of life per world, surfacing unscripted social strategies and interpersonal dynamics that only appear over long timescales.
Simulation as a training signal: The life-reward metric is used to fine-tune more anthropomorphic models, and the improvements transfer beyond the simulation to downstream role-playing benchmarks rather than staying trapped in the sandbox.
Measured gains: Trained agents improve overall CoSER Test performance by 15.6%, with the biggest jumps in Anthropomorphism at 23.7% and Character Fidelity at 16.4%, and they are respected by 24.2% more peers and liked by 15.9% more.
Why it matters: A single 10-year, 100-agent run consumes 13.7 billion tokens across 567,000 LLM calls. That scale is a statement about where agent research is heading: living, learning populations as both an object of study and a source of training data.

Paper | Tweet

6. The Geometry of On-Policy Distillation

On-policy distillation (OPD) has become one of the most discussed post-training recipes of the year, but it has mostly been treated as a black box sitting somewhere between supervised fine-tuning and RL. This paper opens it up, characterizing how OPD changes a model’s weights at the level of parameter geometry, and argues OPD is not a midpoint between SFT and RLVR but its own distinct kind of update.

It touches fewer weights: Compared with SFT, OPD updates affect far fewer parameters and largely avoid the dominant principal directions of weight space, which helps explain its sample efficiency.
Early subspace locking: OPD’s cumulative updates rapidly collapse into a narrow, low-dimensional subspace early in training, rather than spreading across many directions as SFT does.
That subspace is functionally sufficient: Constraining training to the early-formed subspace preserves OPD performance but substantially degrades SFT, showing the small subspace genuinely carries the useful signal rather than being an artifact.
Why it matters: Knowing where in weight space OPD does its work turns a popular but poorly understood recipe into something with a mechanistic account. That makes the method easier to reason about, combine with other objectives, and improve deliberately instead of by trial and error.

Paper

7. Lookahead Sparse Attention

Long-context decoding is bottlenecked by the KV cache, which grows with every token and quickly dominates memory at extreme context lengths. This work, branded around DeepSeek-V4, introduces Lookahead Sparse Attention (LSA), which avoids storing the full KV cache by predicting which parts of the context future decoding will actually need and retaining only those query-critical chunks.

A learned, lightweight indexer: Instead of keeping everything, a small indexer proactively selects the KV chunks that matter for upcoming generation, so the physical cache stays small without discarding information the model will need.
Backbone-free training: A decoupled training strategy lets the indexer be trained on its own without loading the full backbone model, cutting the cost of adding the mechanism to a large model.
Big cache savings, no quality loss: LSA shrinks the physical KV cache to 13.5% of the full-context baseline while slightly improving accuracy by 0.6% on average, and at 500K-token contexts it suppresses more than 90% of KV-cache overhead without destabilizing reasoning.
Why it matters: Ultra-long context is increasingly the difference between a toy demo and a usable system, and memory is the wall. Predicting what context you will need, rather than keeping all of it, is a practical route to long context that fits in real hardware budgets.

Paper

8. Latent Spatial Memory

Video world models struggle to stay consistent over long horizons because explicit 3D memory usually requires an expensive pixel-space loop. Mirage instead stores scene information directly in diffusion latent space, using depth-guided back-projection and latent-space warping to maintain persistent spatial memory. The approach reports up to 10.57 times faster end-to-end generation and 55 times lower memory use than explicit 3D-memory baselines while improving long-horizon spatial consistency.

Paper

9. The Consistency Illusion

Multi-agent debate is often judged by whether the agents end up agreeing, but this paper shows that output-level consensus can hide deep disagreement in the reasoning that produced it. The authors abstract agents’ reasoning traces and decisions into four states along two axes, reasoning similarity and conclusion agreement, and flag divergent agreement, where agents reach the same answer through very different paths. Across 600 content-moderation items, divergent agreement appeared in 118 cases and separated cleanly from genuine disagreement states with a Cohen’s d of 0.80, and routing on these categories beat divergence-only methods at flagging high-disagreement cases.

Paper | Tweet

10. Beyond Scalar Rewards

Reward models usually compress a judgment into a single scalar, but this paper argues human preferences are better captured as score distributions, and proposes Z-Reward, which internalizes reasoning into a predicted distribution before scoring. A large vision-language teacher does the reasoning-heavy judgment and is distilled into a compact student for efficient deployment, with the 27B teacher reaching 89.6% human-preference accuracy and the 9B student nearly matching it at 88.6%. Used as a reinforcement learning signal, it delivers a 41.3% net preference improvement over a supervised baseline, beating GRPO and other reward methods.

Paper

🤖 AI Agents Weekly: Claude Fable 5, Kimi K2.7-Code, NotebookLM Goes Agentic, DiffusionGemma, MiMo Code, and More

Sat, 13 Jun 2026 15:56:07 GMT

In today’s issue:

Anthropic ships Mythos-class Claude Fable 5
Kimi K2.7-Code open-sources a 1T coder
NotebookLM becomes an agentic workstation
Google’s DiffusionGemma generates text in blocks
Xiaomi open-sources MiMo Code agent
Cohere ships North Mini Code
Gemini 3.5 Live Translate goes real-time
Gemini-SQL2 tops BIRD text-to-SQL
Apple rebuilds Siri on Google Gemini
Grok opens a plugin marketplace
Claude Code adds nested subagents
Nex-N2 opens an agentic model series
Extend UI ships document-agent components
Cognition’s FrontierCode raises the eval bar
Study questions the multi-agent advantage
Recursive automates AI research

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

🥇Top AI Papers of the Week

Sun, 07 Jun 2026 15:00:58 GMT

1. Self-Revising Discovery Systems

From MIT, this paper argues that genuine scientific discovery is not answer generation but a change in the search space itself, and that an AI scientist must perceive that shift without being told. It develops a category-theoretic framework in which evidence, artifacts, operations, and verifiers are typed, and discovery is defined as a principled revision of that representational regime rather than more search within a fixed one.

Discovery means changing the regime: The system is built to detect when the representational regime should change and to revise it autonomously. That reframes an AI scientist from a faster searcher into something that can move the boundaries of the space it searches.
A typed, categorical foundation: Evidence, artifacts, operations, and verifiers are formally typed. Old results are carried into the new regime by functorial transport, and what counts as genuine discovery is the residual content that transport alone cannot explain.
Description-length gates keep it honest: Proposed revisions are accepted only when they reduce total description length, which separates real structural gains from mere added complexity. In one run, 388 proposals yield just 25 accepted revisions, a deliberately strict 6.4% rate.
Why it matters: Two concrete instantiations, protein-mechanics modeling and a knowledge-computation graph with typed skills and validation checkpoints, show category theory serving as both a formal language and an engineering spec. It is a more principled blueprint for autonomous discovery than search-only AI scientists.

Paper | Tweet

2. Disentangling Agent Self-Evolution

This paper asks a question every agent builder eventually hits: if an agent rewrites its own harness, does a stronger model make a better self-evolving agent? The answer is no, and the reason is that “self-evolution” is actually two separate abilities that scale very differently. The work separates harness-updating, where an evolver model writes edits to memory, tools, prompts, and skills, from harness-benefit, where a solver model actually exploits those edits on the task.

Updating is flat across model tiers: The quality of harness edits barely depends on model strength. Updates written by Qwen3.5-9B yield gains comparable to those from Claude Opus 4.6, so paying for a frontier model on the evolver side buys almost nothing.
Benefit is non-monotonic: The ability to use a better harness follows a curve. Weak models gain little, mid-tier models benefit most, and the strongest models benefit less than mid-tier ones, often because they already solve the task without the scaffold.
Failure modes are concrete: Weaker solvers either fail to activate the relevant harness component or follow its instructions inconsistently, which is why their gains stay small even when the edits themselves are good.
Why it matters: The practical lever is to put a cheap model on the evolver and spend your capability budget on the solver. System design, not raw model scale, is doing most of the work in agent self-improvement.

Paper | Tweet

3. LEAP

New research from Google shows how far a custom agent harness can push a general-purpose model on formal mathematics. LEAP wraps a general LLM in an agentic scaffold that grounds every step in the Lean compiler and iterates against verifier feedback. Rather than fine-tuning a specialized prover, it leans on informal reasoning, instruction following, and self-refinement, then forces every formal step through a compiler check before moving on.

Decompose, then verify: The scaffold takes the natural form of proof decomposition and verifier-guided refinement. The model breaks a hard theorem into subgoals, drafts an informal blueprint, and the Lean compiler checks each formal step, turning vague reasoning into machine-checkable proof.
Putnam solved in full: On the 2025 Putnam Competition, LEAP solves all 12 problems, matching recent breakthroughs from dedicated frontier math models without any math-specific training of the base LLM.
Large jump on IMO-level proofs: On Lean-IMO-Bench, LEAP lifts the one-shot formal solve rate of general-purpose LLMs from below 10% to 70%, surpassing the 48% set by a specialized, gold-medal-caliber IMO system.
Why it matters: This is strong evidence that a well-built harness, not a bespoke model, can close the gap on one of the hardest reasoning domains. The leverage sits in the scaffold and the verifier loop around a general model.

Paper | Tweet

4. Scaling Laws for Agent Harnesses

Most harness tuning treats every token and tool call as if volume is what counts. This paper shows that it mostly does not, and introduces Effective Feedback Compute (EFC), a trace-level scaling coordinate that credits feedback only when it is informative, valid, non-redundant, and retained for later decisions, then normalizes by task demand.

Raw budget barely predicts success: In controlled scaling, raw tokens and tool calls explain limited variation in outcomes, with R-squared of 0.33 and 0.42. The usual cost proxies are weak predictors of whether the agent actually succeeds.
Effective feedback nearly explains everything: Oracle-EFC normalized by task demand reaches an R-squared of 0.99. Once you measure feedback that is genuinely useful and retained, the scaling behavior becomes almost fully predictable.
Quality beats quantity at fixed budget: In matched-budget interventions, improving feedback quality raises success from 0.27 to 0.90 while raw cost and tool calls stay fixed. The win comes from better feedback, not more of it.
Why it matters: Harness scaling is governed less by how much compute you spend than by how efficiently raw budget converts into durable, task-sufficient feedback. That reframes harness engineering as a feedback-quality problem and gives a coordinate to optimize against.

Paper | Tweet

Message from the Editor

We just released hands-on labs on DAIR Academy to help you build alongside agents. Start with practical, guided labs for agentic image generation and building your first agent skill, with more labs coming soon.

Explore the Labs

5. AutoLab

Can frontier models actually grind on a hard engineering problem the way a good researcher does? AutoLab is a benchmark for ultra long-horizon, closed-loop optimization built to answer that. It contains 36 realistic, expert-curated tasks across four domains: system optimization, puzzle and challenge, model development, and CUDA kernel optimization. Each task hands the agent a correct but deliberately suboptimal baseline and asks it to improve within a strict wall-clock budget.

Persistence beats a strong start: The dominant predictor of final performance is not the quality of the initial solution but the agent’s persistence in iterative refinement. Models that keep probing and improving win, regardless of where they began.
Most models quit early: While Claude Opus 4.6 shows strong long-horizon optimization, most frontier models, including several proprietary ones, either terminate prematurely or burn their budget with minimal progress.
Time awareness is the gap: The results point to time-awareness and sustained iteration, not raw single-shot capability, as the missing ingredient for truly capable long-horizon agents.
Why it matters: Day-one benchmarks reward clever first attempts, but real research and engineering reward stamina. AutoLab measures the thing that actually separates agents on multi-hour tasks, and the benchmark, harness, and task artifacts are open-sourced.

Paper | Tweet

6. Reusable Context Engineering

Context bloat quietly kills long-horizon runs, and the usual fixes are baked into an agent’s own prompt or weights, so they do not transfer. AdaCoM takes a different route: it trains a separate external model to manage the context of a frozen agent through flexible modification actions, optimized end-to-end with reinforcement learning. The agent never changes; only the context flowing into it does.

An external context manager: A dedicated model edits the agent’s working context, deciding what to keep, compress, or drop. Because it sits outside the agent, it can be reused as a drop-in component rather than re-engineered per backbone.
Trained with reinforcement learning: The manager is optimized end-to-end against task outcomes, learning context-editing policies instead of relying on hand-written heuristics or fixed truncation rules.
Transfers across similar agents: Transfer experiments show AdaCoM generalizes most effectively across agents of similar capability, pointing toward genuinely reusable context managers. It improves web search and deep research by preserving task constraints and progress while pruning stale content.
Why it matters: Treating context management as a separate, trainable, transferable module decouples it from the agent itself. That is a cleaner abstraction than stuffing context logic into every prompt, and it fixes bloat from the outside without touching the underlying model.

Paper | Tweet

7. Learn From Your Own Latents

LLMs learn by predicting tokens, while world models like JEPA and data2vec learn by predicting their own internal representations. This paper provides a sample-complexity theory for why the second approach can be dramatically more data-efficient, using a tractable probabilistic context-free grammar as the analytical setting where compositional structure can be measured exactly.

Exponential gap in data efficiency: Predicting your own latents requires a number of samples that is constant in the tree depth L, whereas supervised and token-based self-supervised learning need samples that grow exponentially in L. The advantage is structural, not incidental.
Why latents win: Latent targets expose the compositional, hierarchical structure of the data directly, so the learner does not have to reconstruct it from surface tokens. That is the mechanism behind the data-efficiency gain.
Hierarchy may be implicit: The analysis suggests that explicit hierarchical stacking, as in H-JEPA, can be largely redundant, because methods like data2vec already learn hierarchical structure implicitly.
Why it matters: As token-prediction scaling laws press against data limits, this gives a principled argument for self-supervised objectives that predict abstractions instead of tokens. It is a theoretical foundation for why world-model-style training could beat brute-force next-token prediction on sample efficiency.

Paper | Tweet

8. A Primer on Post-Training Reasoning Data

This primer is the first to pull the scattered post-training reasoning-data literature into one place, synthesizing over 150 public studies and system reports that previously lived across dataset papers, RL write-ups, and lab reports. It organizes the field around four questions: what data objects exist, what makes them useful, how they are constructed, and how they scale. The key reframing is that a reasoning-data item is more than a prompt-response pair: it packages a problem or state, model behavior, judging feedback, and attribution metadata, with usefulness defined relative to the verifier and the rest of the corpus rather than in isolation.

Paper | Tweet

9. State-Externalizing Harnesses

Harness-1 is a 20B search agent trained with reinforcement learning inside a stateful harness that offloads routine bookkeeping to the environment. The argument is that search agents are usually trained as policies over a growing transcript, forcing RL to optimize both genuine search decisions and recoverable state like which evidence is useful or which claims are checked. Harness-1 moves that state out of the policy and into an environment-side working memory of candidate pools, an importance-tagged curated set, compact evidence links, and verification records. The 20B agent reaches an average curated recall of 0.730 across eight retrieval benchmarks, beating open-source baselines by 11.4 points and matching or outperforming much larger frontier searchers, with stronger generalization on unseen domains.

Paper | Tweet

10. Do More Agents Help?

This paper studies whether adding agents actually makes a single LLM-driven multi-agent system better, using a Sequential Iterative Multi-Agent System (SIMAS) framework. The finding is that performance does not scale monotonically with agent count but follows a pattern of diminishing returns, with degradation eventually driven by coordination overhead. Effective systems still require a capable base model, the optimal number of agents depends on the task type, and collective intelligence turns out to be a product of strategic interaction design rather than a guaranteed outcome of agent plurality. The takeaway for builders is to design the interaction, not just stack more agents.

Paper | Tweet

🤖 AI Agents Weekly: Microsoft's Seven MAI Models, Gemma 4 12B, NVIDIA Nemotron 3 Ultra, Agents' Last Exam, Devin Desktop, and More

Sat, 06 Jun 2026 15:01:28 GMT

In today’s issue:

Microsoft ships seven new MAI models
MAI-Thinking-1 takes on Claude Sonnet
Gemma 4 12B runs agents on a laptop
NVIDIA opens 550B Nemotron 3 Ultra
Anthropic warns of recursive self-improvement
Agents’ Last Exam stumps frontier agents
Claude Platform gets an ant CLI
Cognition launches Devin Desktop
Nous ships Hermes Desktop
Codex builds iOS apps end-to-end
ChatGPT memory learns to dream
Multi-agent computer use beats solo CUAs
Economy of Minds prices agent actions
LEAP solves all 12 Putnam problems
A harness rewrites itself for +19 SWE points

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

🥇Top AI Papers of the Week

Sun, 31 May 2026 15:01:30 GMT

1. SkillOpt

Microsoft Research treats a compact natural-language skill document as the trainable state of a frozen agent, then learns that document through rollouts, reflection, and bounded edits gated by held-out validation. The argument is direct: most engineers handwrite agent skill docs and hope they generalize, when the doc itself should be optimized like a parameter. SkillOpt reframes the SKILL.md file as an external parameter of a model whose weights never change.

The skill doc as a trainable parameter: An optimizer model proposes validation-gated edits to the skill file, adding, deleting, or replacing instructions. A textual learning rate controls how aggressively each round rewrites the document, with batch and momentum reported in text space rather than gradient space.
Validation gates instead of hope: Every edit must pass a held-out check before it is kept. This turns skill authoring into a measurable optimization loop with a real objective, rather than prompt tweaking guided by intuition.
52 out of 52 wins: SkillOpt beats Trace2Skill, TextGrad, GEPA, EvoSkill, human-written skills, and one-shot skills across 6 benchmarks and 7 target models. It adds roughly +23.5 points on GPT-5.5 in direct chat, +24.8 in the Codex loop, and +19.1 in Claude Code from the no-skill baseline.
Why it matters: If the skill document is the thing you optimize, the bottleneck shifts from base-model capability to how well you can train the natural-language state around a frozen agent. That is a cheap, model-agnostic lever most teams are leaving on the table.

Paper | Tweet

2. Compiling Agentic Workflows into Weights

This paper shows that a full agentic workflow can be distilled into the weights of a small model and run at roughly two orders of magnitude lower inference cost while preserving near-frontier task quality. Instead of keeping an external orchestrator above the LLM, the procedure is compiled into the weights of a fine-tuned model, producing what the authors call a subterranean agent.

The whole workflow, not just the answer: The compiled procedure includes multi-step LLM calls, tool invocations, intermediate scratchpads, and decision points. The student internalizes the orchestration logic rather than only imitating final outputs.
Orchestrator dissolved into the model: Classic agent frameworks run a planner loop above the model on every request. Compiling that loop into weights removes the per-call orchestration overhead, which is where most of the cost and latency live.
Near-frontier quality at 100x less cost: Across the evaluated tasks, the distilled small model stays close to the original workflow’s quality while cutting inference cost by about two orders of magnitude. The savings come from collapsing many model calls into one forward pass.
Why it matters: Most production agents pay repeatedly for an orchestration loop they run thousands of times a day. If that loop can be compiled once into a cheap model, the economics of deploying agentic systems change substantially, especially for high-volume narrow workflows.

Paper | Tweet

3. AutoScientists

AutoScientists, from Harvard, is a decentralized team of AI agents for long-running computational science that drops the central planner entirely. Rather than following one research trajectory coordinated from the top, agents self-organize around promising hypotheses, critique each other’s proposals before spending experimental compute, and record both successes and failures so the system avoids redundant exploration as evidence accumulates over hours or days.

No central planner: Agents interpret shared experimental state, form teams around promising directions, and reorganize when progress stalls. Coordination emerges from a common state rather than a top-level controller, which sustains parallel search instead of a single thread.
Evaluate before you spend: Proposals are critiqued and scored before any experimental compute is allocated. This gating reduces wasted trials and keeps the system from repeating dead ends that an individual agent would otherwise revisit.
Strong results on real science tasks: On BioML-Bench, 24 biomedical ML tasks spanning imaging, protein engineering, single-cell omics, and drug discovery, AutoScientists reaches 74.4% mean leaderboard percentile, an improvement of +8.33% over the strongest prior AI agent.
Why it matters: Most multi-agent research systems still funnel decisions through a planner that becomes a bottleneck. Decentralized self-organization with explicit failure-sharing is a different blueprint for long-horizon scientific search, and it holds up on hard biomedical benchmarks.

Paper | Tweet

4. Language Models Need Sleep

Attention scales badly with context length, so long-horizon agents keep paying a growing cost as their context grows. This paper studies a sleep-like consolidation mechanism: the model periodically converts recent context into persistent fast weights, then clears its key-value cache. During the sleep phase it performs offline recurrent passes over the accumulated context and updates fast weights in its state-space blocks through a learned local rule.

Consolidate, then clear the cache: Recent context is folded into fast weights stored in the model’s SSM blocks before the KV cache is discarded. The agent keeps what it learned without carrying the full attention bill into every future step.
Compute moves to sleep, latency stays at wake: The extra work happens offline during consolidation, so wake-time prediction keeps its low latency. The tradeoff is explicit and controllable rather than hidden in a ballooning context window.
More sleep helps the hardest cases: Increasing sleep duration improves performance, with the largest gains precisely on tasks that require the most complex reasoning over long histories. The mechanism buys the most where naive attention struggles most.
Why it matters: Long-horizon agents are the first systems to feel the quadratic cost of context. A biologically inspired consolidation step gives a principled alternative to ever-longer context windows, and it maps cleanly onto the state-space architectures already used for efficiency.

Paper | Tweet

Message from the Editor

Explore the Labs

5. Adapting the Interface, Not the Model

When a frozen LLM agent repeatedly fails in a deterministic, rule-governed environment, do you have to retrain the model? Life-Harness argues no. Many failures come from mismatches at the model-environment interface, not from the model’s reasoning, so the fix belongs in the runtime harness. Life-Harness is a lifecycle-aware harness that improves frozen agents without touching model weights or the evaluation environment.

Failures become reusable interventions: Recurring errors are turned into runtime fixes across four areas: action realization, environment contracts, trajectory regulation, and procedural skills. Each fix is a harness-level patch the agent reuses on later attempts.
Model frozen, environment intact: Nothing about the model or the benchmark changes. Only the interface between them adapts, which keeps the approach drop-in for any backbone and avoids the cost and risk of fine-tuning.
Broad, consistent gains: Across 7 deterministic agent benchmarks and 18 model backbones, Life-Harness improves 116 of 126 model-environment settings, with an 88.5% average relative improvement. The effect holds across model scales rather than helping only weak models.
Why it matters: This is more evidence for the code-as-harness thesis: a large share of agent failures are interface problems that harness engineering can fix without retraining. For builders, the leverage is in the runtime, not the model.

Paper | Tweet

6. The Efficiency Frontier

Context costs dominate production LLM bills, and the right strategy depends on how often preprocessing gets reused. This paper models context-strategy selection as a deployment-aware optimization problem that jointly accounts for task performance, token cost, and reuse, then uses it to compare retrieval-based and preprocessing-based approaches under realistic constraints.

A reuse-aware cost model: A parameterized log-utility metric captures diminishing returns from more context while charging an amortized preprocessing cost. Varying a reuse parameter lets the framework compare strategies under different deployment patterns on equal footing.
Distinct operating regimes: The analysis reveals clean transition boundaries between retrieval and preprocessing strategies. Which one wins flips depending on how many times you reuse the preprocessed context, so a single default is rarely optimal.
Real token savings: On 5,000 HotpotQA instances, deployment-aware optimization cuts effective token usage by roughly 25% at comparable performance, and amortized memory compression achieves over 50% lower token cost relative to full-context.
Why it matters: Most teams pick a context strategy once and pay for it on every request. Treating context management as an explicit cost-performance optimization turns a guess into a measurable decision, with double-digit savings available on common workloads.

Paper | Tweet

7. Forecasting Scientific Progress with AI

Can frontier models predict where science is going? This work introduces CUSP, a cutoff-conditioned benchmark built from 4,760 real scientific events across multiple disciplines, each grounded against a verified knowledge cutoff. For every event, models are tested on four tasks: feasibility assessment, mechanistic reasoning, generative solution design, and temporal prediction. The headline is sobering: models recognize plausible directions but cannot forecast outcomes.

Recognition is not foresight: Models can identify plausible research directions when choosing among competing candidates, but they fail to reliably predict whether an advance will actually be realized, and they systematically misestimate when it will happen.
Domain-dependent, and timing is hardest: Performance is highly heterogeneous across fields, with the timing of AI progress more predictable than advances in biology, chemistry, and physics. Temporal prediction is the weakest skill across the board.
Not just a training-cutoff artifact: Performance is largely insensitive to whether an event falls before or after the model’s training cutoff. Extra pre-cutoff knowledge helps but does not close the gap to full-information settings, and that gap widens for high-citation advances.
Why it matters: Models also show systematic overconfidence and strong response biases, which means unreliable uncertainty estimates. As labs lean on AI to triage research bets, CUSP gives a controlled way to measure where it helps, surfacing directions, and where it fails, predicting outcomes.

Paper | Tweet

8. Your Agents Are Aging Too

AgingBench is a longitudinal reliability benchmark for agent lifespan engineering, built on the observation that long-lived agents are still evaluated like freshly initialized models. It organizes agent degradation into four mechanisms: compression aging, where write-time summarization drops future-relevant details; interference aging, where accumulated similar memories crowd out the target fact; revision aging, where changed or derived state is not updated correctly; and maintenance aging from routine lifecycle events. Using a temporal dependency DAG to encode cross-session structure, it produces aging curves over an operational lifetime rather than a single day-one score, and points to where repair should target.

Paper | Tweet

9. Harnesses Are Not Uniformly Better

This paper studies LLM agent harnesses through the lens of inference-time trajectory alignment, separating a harness into two mechanisms: task decomposition, which structures a task into sub-goals, and guided execution, which reshapes local action distributions during execution. The key finding is that more elaborate harnesses are not uniformly better. Increasing decomposition or guidance can improve execution but can also reduce final task success, producing concrete failure modes like over-decomposition, over-pruning, and hallucinated execution. Strikingly, partial harnesses that specify only the initial steps and leave the rest to the agent can reach a higher pass rate than fully structured workflows.

Paper | Tweet

10. Epicure

Epicure trains a family of multilingual ingredient embeddings from scratch on 4.14 million recipes aggregated from 11 sources across seven languages, with raw ingredient strings normalized to 1,790 canonical entries via an LLM-augmented pipeline. It ships three skip-gram (Metapath2Vec) variants that share architecture but differ in what they walk: recipe co-occurrence only, chemical-compound structure from FlavorDB only, or a blend of both, placing each model at a different point on the chemistry-versus-recipe-context spectrum. The result is a compact, downloadable map of the emergent geometry of food, a clean reminder that representation learning generalizes well beyond text into surprisingly everyday domains.

Paper | Tweet

🤖 AI Agents Weekly: Claude Opus 4.8, Claude Code Dynamic Workflows, Chrome DevTools for Agents 1.0, DeepSWE, Agent Harness Scaling Laws, and More

Sat, 30 May 2026 15:02:03 GMT

In today’s issue:

AutoScientists self-organize agent teams
Anthropic ships Claude Opus 4.8
Claude Code adds dynamic workflows
Chrome DevTools for agents hits 1.0
DeepSWE raises the coding-agent bar
xAI opens grok-build-0.1 in beta
Microsoft open-sources Webwright for agents
Scaling laws for agent harnesses land
Harness sensitivity proves non-monotone
SIA co-updates harness and weights
CUA-Gym scales computer-use RL data
Polar trains agents on real harnesses
Anthropic details how it contains Claude
Xiaomi slashes MiMo-V2.5 API prices
Language models learn to sleep
a16z maps the AI application layer

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

🥇Top AI Papers of the Week

Sun, 24 May 2026 15:01:51 GMT

1. Code as Agent Harness

A 100+ page survey treating the agent harness as a first-class research object rather than glue around an LLM. The authors argue that code-as-harness is the most promising path to general-purpose agency, and that future agent systems should satisfy four properties: executable, inspectable, stateful, and governed. The report consolidates methods, applications, and open problems across the harness layer.

Harness engineering as a discipline: The paper frames harness design as a science distinct from model training, with its own primitives, failure modes, and evaluation criteria. The taxonomy gives a vocabulary for comparing systems that has been missing in prior agent literature.
Four-property test for production agents: Executable, inspectable, stateful, and governed. Each property maps to a class of operational concerns. The authors use it to audit current open-source agent frameworks and identify where defaults fall short.
Code as the unifying substrate: Across browsing, tool use, and multi-step reasoning, harnesses that compile decisions into code consistently outperform JSON-call orchestration on the surveyed benchmarks. The paper traces this back to determinism, composability, and inspectability of the resulting traces.
Why it matters: If code-as-harness is the right substrate, then the next round of agent-system progress will come from harness-level innovation rather than from new base models. The survey gives builders a structured reference for that work.

Paper | Tweet

Message from our Sponsor

Intology released NanoGPT-Bench, a benchmark that drops agents into the NanoGPT Speedrun environment at the September 2025 human world record and measures how much of the next five months of community progress they can recover autonomously.

Claude Code, Codex, and Autoresearch each ran 320 to 455 training variants on a 512 H100-hour budget and recovered under 10% of the human speedup, mostly via hyperparameter tuning rather than algorithmic research.

2. OpenAI Disproves the Unit Distance Conjecture

This OpenAI paper disproves Erdős’s 1946 unit distance conjecture. For a finite planar set P, let ν(P) count the unordered pairs at distance exactly 1, and let ν(n) be the maximum of ν(P) over all n-point sets. Erdős conjectured ν(n) ≤ n^(1+C/log log n); the paper proves instead that there is a fixed δ greater than 0 with ν(n) ≥ n^(1+δ) for infinitely many n. The result was produced in a completely automated fashion by an internal OpenAI model and then human-edited into the present exposition.

The theorem: There exists an absolute constant δ greater than 0 and infinitely many n for which ν(n) ≥ n^(1+δ). This contradicts the widely believed conjecture, which earlier results on generic and most planar norms had appeared to support.
The construction: It passes through an infinite unramified tower of totally real number fields with 3-power Galois groups of growing degree, in which a fixed set of rational primes splits completely. After adjoining i, these fields produce high-dimensional lattices with many elements whose images have absolute value 1 under every complex embedding. The construction is a high-dimensional analogue of the arithmetic behind Erdős’s classical square-grid lower bound.
Why it works: Golod-Shafarevich theory guarantees an infinite tower exists, even after a quotient step that trivializes the prescribed Frobenius classes. A crucial property is that all resulting discriminants and class numbers stay at most exponential in the extension degree.
Statement on AI use: The internal model was given an AI-written problem statement, and its output was checked by an AI grading pipeline before any human examined it. After AI-assisted verification and rewriting, a draft was sent to external mathematicians, including number theory experts, who confirmed the proof’s correctness and have since simplified and strengthened the argument.

Paper | Tweet

3. Memory as a Model

MeMo augments any frozen LLM with a separately trained memory model that stores, retrieves, and integrates facts on the base model’s behalf. Memory updates are decoupled from base-model weight updates, so the system supports continual learning without catastrophic forgetting, a property RAG fails to deliver because a vector store is just a database with a learned encoder bolted on.

Memory as a learned subsystem: MeMo has explicit read, write, and integrate interfaces rather than relying on the context window. The position is that memory in agents should be modular, learned, and gated.
Decoupled update schedule: New facts are absorbed through the memory model’s training loop without touching backbone weights. This makes weekly knowledge updates feasible without retraining and without vector-DB churn.
Continual-learning robustness: Across the evaluated tasks, the system retains old knowledge while ingesting new knowledge, addressing a known failure mode of fine-tuning and a known limitation of retrieval-based memory.
Why it matters: Most production agent systems still bolt a vector store onto an LLM and call it memory. MeMo proposes that memory should be a trained component with explicit interfaces, which has implications for how long-running agent platforms are architected.

Paper | Tweet

4. AIRA

Meta’s AIRA is an agent system that autonomously discovers neural architectures, producing models that beat Llama 3.2 at 350M, 1B, and 3B scales under a 24-hour compute budget. The search is split across two specialized agents: AIRA-Compose searches macro architecture, and AIRA-Design implements the low-level mechanisms. The split outperforms a single end-to-end agent on this non-toy search problem.

Two-agent decomposition: A planner picks structure; an implementer fills in mechanisms. This pattern generalizes well beyond neural architecture search to pipeline assembly, query planning, prompt scaffolding, and tool-use programs.
Beats Llama 3.2 at three scales under budget: Discovered architectures match or exceed Llama 3.2 at 350M, 1B, and 3B parameter scales within a 24-hour compute budget for the search itself. That is competitive with months of human-led ablation studies.
Search not synthesis: The discovered models are not LLM-written code patches grafted into a framework. They are full architectures discovered through structured search guided by the two-agent loop.
Why it matters: If agentic search can produce competitive architectures end to end, then NAS and large parts of the ML research workflow become candidates for automation by agent systems rather than by hand-engineered search algorithms.

Paper | Tweet

5. Weak-Model Critic-Comparator

GPT-5.4 nano wrapped in a critic-comparator orchestration loop reaches 76.4% on SWE-bench Verified, matching standalone Gemini 3 Pro and Claude Opus 4.5 Thinking. The trick is to sample k=8 candidate patches from the weak model and select the winner using execution and proof signals rather than asking the model to self-rank.

k=8 candidates plus verifier beats frontier model: A weak model’s top-k often already contains a correct patch. The selector is the limiting factor, not the base model’s capability.
Execution and proof signals as selection: Candidates are run and verified rather than scored by an LLM judge. The critic and comparator are separate roles inside the loop, each with a narrow task.
Matches frontier performance at lower per-call cost: Selecting among nano-tier proposals is cheaper than calling a frontier model once, even after accounting for the 8x sampling, because the dominant cost driver is model size rather than call count.
Why it matters: This is a reproducible recipe for getting frontier-level coding-agent results out of cheaper models. The result also reframes where SWE-bench progress is coming from: orchestration quality, not just stronger base models.

Paper | Tweet

6. MetaCogAgent

MetaCogAgent equips a multi-agent system with metacognition, so each agent decides whether it should answer or delegate. The bottleneck in current multi-agent systems is over-delegation and under-delegation, and a metacognitive gate is a principled way to manage both. The Metacognitive Unit (MCU) at each agent produces confidence scores that drive routing to a delegation hub.

Confidence-driven routing: Each agent’s MCU combines verbalized and profile-based confidence into a single score. Low-confidence tasks route to a delegation hub rather than getting answered anyway.
Self-aware specialization beats fixed routers: MetaCogAgent reaches 82.4% on MetaCog-Eval, versus 70.2% for a skill-fixed router and 65.3% for single-agent. Self-assessment and adaptive delegation each contribute material gains in ablations.
Emergent specialization: Distinct confidence profiles (high on coding, low on retrieval, etc.) emerge purely from feedback. No specialization is encoded beyond initial system prompts.
Why it matters: Multi-agent systems usually rely on fixed routers or simple round-robin schemes. A learned, uncertainty-aware delegation gate gives a primitive that adapts to task difficulty without retraining the routing layer.

Paper | Tweet

7. Production Agent Architecture Methodology

A methodology paper on selecting and composing runtime architecture patterns for production LLM agents. The core argument is that most teams accidentally let framework defaults make critical architecture decisions for them. The paper introduces the stochastic-deterministic boundary (SDB) as a named primitive and presents a six-pattern catalog organized by the three runtime concerns of coordination, state, and control.

Stochastic-deterministic boundary: A four-part contract of proposer, verifier, commit, and reject that marks where the LLM hands off to deterministic infrastructure. The paper inventories how five widely used open-source agent frameworks place this boundary, often implicitly.
Three-by-six pattern catalog: Six patterns organized along three orthogonal concerns. Coordination patterns answer how work splits and combines. State patterns answer how the system remembers. Control patterns answer who decides what runs and when to stop.
Patterns as deliberate choices: Each pattern has a typed-contract specification of input type, output type, deadline, retry budget, and partial-result policy. The catalog grows by passing this procedure rather than by adding ad-hoc abstractions.
Why it matters: Production agent failures rarely come from the LLM. They come from architectural choices that were made by default. The methodology gives teams a way to surface those choices and make them deliberately.

Paper | Tweet

8. NanoGPT-Bench

A new evaluation of whether coding agents can do real AI R&D. Intology runs Codex, Claude Code, and Autoresearch on the NanoGPT-Bench suite and reports that the agents recover only 9.3% of human progress on the same problems. Coding agents spend the bulk of their compute on hyperparameter tuning and rarely attempt algorithmic research. Claude Code and Autoresearch reason about algorithmic changes more often, but still tend to dodge implementing them. The headline result tempers the current wave of “self-improving agent” claims: producing real research progress requires a different distribution of effort than the one current coding agents converge to under their default scaffolds.

Paper | Tweet

9. General-Agent

Prime Intellect’s General-Agent is a fully synthetic reinforcement learning environment whose task corpus self-evolves and grows harder over time. The release ships with 4,504 tool-use tasks across 1,040 domains and 8,159 unique tools. Synthetic task creation is formulated as a two-player game between a Synthesizer that proposes new task families and a Solver that runs rollouts to measure pass rates. Tasks whose pass rate falls inside a calibrated difficulty band are accepted into the corpus, and hard tiers seed the next round of extensions. The framing turns RL environment creation, historically a major bottleneck, into an automated agentic search problem in its own right.

Paper | Tweet

10. Contrastive Neuron Attribution

Nous Research releases Contrastive Neuron Attribution (CNA), a method for steering LLM behavior by identifying and ablating sparse circuits in the MLP basis without training a sparse autoencoder, modifying weights, or degrading general capability benchmarks. Given a small set of contrastive prompt pairs that elicit a target behavior and its opposite, CNA isolates the top 0.1% of MLP neurons whose activations differ most between the two sets. Ablating that small circuit removes the behavior while leaving the rest of the model intact. The intervention remains robust at high strengths where residual-stream methods like Contrastive Activation Addition (CAA) start to degrade. Validated on the refusal circuit across 8 instruct-tuned models including Llama-3.1-70B, Llama-3.2-3B, Qwen2.5-72B, and Qwen2.5-14B.

Paper | Tweet

🤖 AI Agents Weekly: Gemini 3.5 Flash, Antigravity 2.0, Codex Thursday, Cohere Command A+, Qwen3.7-Max, and More

Sat, 23 May 2026 15:02:42 GMT

In today’s issue:

Google ships Gemini 3.5 Flash for agents
Antigravity 2.0 becomes a full agent platform
OpenAI ships Appshots and /goal in Codex
Cohere open-sources Command A+ on Apache 2.0
Qwen3.7-Max runs agents for 35 hours straight
NVIDIA verifies agent skills
Cursor Composer 2.5 sharpens coding agents
Anthropic acquires Stainless for SDK tooling
Browserbase opens Browse.sh skills catalog
Gemini Omni unifies create-anything model
OpenAI cracks an 80-year Erdős problem
Compiling agent workflows into model weights
PEEK orientation cache for long-context agents
SaaS-Bench exposes computer-use agent ceiling

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

🥇Top AI Papers of the Week

Sun, 17 May 2026 15:02:22 GMT

The Top AI Papers of the Week (May 11 - May 17)

1. Lighthouse Attention

Nous Research proposes a training-only attention wrapper for long-context pretraining. Lighthouse Attention wraps standard SDPA with a hierarchical, gradient-free selection layer that compresses and decompresses queries, keys, and values symmetrically while preserving left-to-right causality. The wrapper is removed near the end of training in a short recovery phase, so the deployed model runs vanilla attention with no architectural change at inference. Preliminary LLM experiments report faster total training time and lower final loss than full-attention baselines.

Subquadratic wrapper with vanilla deployment: The hierarchical selector reduces the cost of long-context training without modifying the underlying attention operator. After the recovery phase, the trained weights are compatible with standard SDPA at inference.
Symmetric compression preserves causality: Queries, keys, and values are compressed and decompressed through the same hierarchy, which keeps the wrapper compatible with left-to-right attention.
Training-time speedup at lower final loss: Preliminary runs report faster wall-clock training and lower final loss than full-attention baselines under matched FLOPs, including 21x faster forward latency at 512K context.
Why it matters: A training-only modification that leaves the deployed model unchanged sidesteps the usual deployment-time tradeoffs of efficient-attention methods.

Paper | Tweet

Message from the Editor

We just released new hands-on labs on DAIR.AI Academy to help you build alongside agents. Start with practical, guided labs for agentic image generation and building your first agent skill, with more labs coming soon.

Enroll

2. Is Grep All You Need?

The paper evaluates grep-style text search against embedding-based retrieval inside coding agents. When wrapped in a suitable agent harness, grep matches or exceeds embedding retrieval on coding-agent tasks. The study isolates the contribution of the harness from the contribution of the retrieval primitive, and finds that harness design accounts for most of the performance differential typically attributed to embeddings.

Direct comparison of grep vs. embeddings: Coding-agent tasks evaluated under controlled conditions show grep-based retrieval reaching parity with or exceeding embedding-based retrieval.
Harness design as the dominant variable: Holding the index constant and varying the harness produces larger performance shifts than the inverse, indicating that retrieval comparisons in prior work have likely been confounded by harness differences.
Implications for codebase structure: Grep performs best when the codebase is properly indexed and structured for an agent to navigate, while embedding retrieval can partially compensate for unstructured input.
Why it matters: Vector databases are a common default in coding-agent stacks. The result suggests that for many coding tasks, harness improvements and basic text search can substitute for embedding infrastructure.

Paper | Tweet

3. A Geometric Calculator Inside a Neural Network

Goodfire reports mechanistic interpretability work identifying a geometric calculator inside an LLM. The model represents numbers as Fourier features, where circles in activation space correspond to numbers modulo a given base. Arithmetic operations are implemented as rotations of these circles, forming a variant of a residue number system that does not require coprime moduli. The same circuit appears to be reused beyond arithmetic.

Numbers as rotating circles: Numerical quantities are encoded as positions on circles in activation space, with addition implemented as rotation. The encoding extends prior findings that LLMs represent numbers via Fourier features.
Residue-system-like structure: The set of circles forms a residue number system variant. Unlike the textbook residue system, the moduli do not need to be coprime, which is the mechanistic detail the paper introduces.
Reuse beyond arithmetic: The same rotational machinery shows up in non-math contexts inside the model, suggesting the geometric calculator is a general-purpose internal structure rather than a math-specific subnetwork.
Why it matters: The finding gives interpretability researchers a concrete, reproducible circuit to target and connects geometric representation analysis to functional behavior beyond toy settings.

Paper | Tweet

4. δ-mem

δ-mem augments a frozen full-attention model with a compact online associative-memory state. The state is a fixed-size matrix updated by delta-rule learning during generation, and its readout produces low-rank corrections to the backbone’s attention output. There is no fine-tuning, no backbone swap, and no context extension.

Frozen backbone: The base model weights are unchanged. δ-mem adds a small online state plus a pair of low-rank read and write projections.
Delta-rule update integrated into attention: The memory matrix is updated by delta-rule learning during generation, and the readout produces additive query and output corrections to the attention computation rather than functioning as a separate retrieval step.
Results from an 8x8 state: An 8x8 online memory lifts the frozen backbone’s average score by 1.10x and beats the strongest non-δ-mem memory baseline by 1.15x. On memory-heavy benchmarks the gap widens: 1.31x on MemoryAgentBench and 1.20x on LoCoMo. General capabilities are largely preserved.
Why it matters: The mechanism offers an alternative to context extension and external retrieval for long-horizon memory, with minimal deployment overhead on frozen frontier models.

Paper | Tweet

5. Beyond Individual Intelligence

A multi-agent systems survey covering 200+ papers, organized along three axes: collaboration mechanisms, failure attribution, and self-evolution. Each axis is treated as a distinct research line. The self-evolution chapter maps how memory, meta-learning, and procedure-editing approaches intersect.

Three orthogonal axes: Collaboration mechanisms cover who communicates with whom and how. Failure attribution covers methods for localizing errors across agents. Self-evolution covers how a system updates its own behavior over time.
Failure attribution as a first-class topic: Errors propagate through coordination protocols in multi-agent systems, making attribution difficult. The survey treats attribution methodology as a research area rather than a debugging activity.
Self-evolution as a field map: The chapter identifies overlap between memory work, meta-learning, and procedure-editing approaches, and surfaces open questions in each area.
Why it matters: The taxonomy provides a vocabulary for comparing multi-agent systems along axes that prior work has often conflated.

Paper | Tweet

6. AutoTTS

AutoTTS reframes test-time scaling as a search problem. Instead of designing branching, pruning, and stopping heuristics directly, the user constructs a discovery environment in which TTS strategies are searched automatically. Width-depth TTS is recast as controller synthesis over pre-collected reasoning trajectories and probe signals, so candidate controllers can be evaluated without repeated LLM calls.

Discovery environment plus offline evaluator: The human specifies states, actions, and feedback. An explorer LLM iteratively proposes candidate controllers. Controllers are evaluated against pre-collected trajectories rather than by re-sampling the base model.
Beta parameterization and trace-level feedback: Beta parameterization makes the controller space tractable for search. Execution-trace feedback gives the explorer information about why a candidate failed, not only that it did.
Results on math reasoning benchmarks: Discovered controllers outperform hand-designed TTS recipes on the accuracy-cost Pareto frontier and transfer zero-shot to held-out benchmarks and model scales. Total discovery cost: $39.9 and 160 minutes.
Why it matters: Automated search over TTS strategies is competitive with hand-tuned heuristics at low cost, which shifts where the research effort needs to go.

Paper | Tweet

7. AI Co-Mathematician

Google DeepMind presents AI Co-Mathematician, an agentic research workbench for mathematicians. The system is an asynchronous, stateful environment that supports ideation, literature discovery, computational analysis, theorem verification, and knowledge development across long sessions. It reaches 48% on FrontierMath Tier 4, a new high among AI systems evaluated.

Asynchronous stateful workbench: The system runs as a persistent environment with multiple workstreams a mathematician can drive in parallel. Long-running computations, literature searches, and verification steps run in the background.
Manages uncertainty and intent: The workbench records unsuccessful attempts, clarifies user intent when underspecified, and emits formal mathematical outputs that can be checked rather than only read.
48% on FrontierMath Tier 4: A new high score on the hardest tier of FrontierMath among AI systems evaluated. Early applications produced solved open problems, fresh research directions, and recovered overlooked citations during active research sessions.
Why it matters: The workbench design pattern (asynchronous, stateful, multi-workstream) generalizes to expert workflows where sessions span days rather than minutes.

Paper | Tweet

8. AEvo

AEvo separates the iterative self-improvement loop into two roles: a candidate-proposer that generates the next attempt, and a meta-agent that observes traces and edits the procedure used to propose future candidates. Past runs (candidates, feedback, traces, failures) function as memory the meta-agent reads from when revising the procedure. AEvo reports a 26% relative gain over the strongest evolution baseline on agentic and reasoning benchmarks, and SOTA on three open-ended optimization tasks under the same iteration budget. The work demonstrates one way to operationalize accumulated agentic search logs as input to procedure-level updates rather than discarding them after each run.

Paper | Tweet

9. The Memory Curse in LLM Agents

A study of how long histories affect LLM agent behavior. Across 7 LLMs and 4 social dilemma games over 500 rounds, expanding accessible history degraded cooperation in 18 of 28 model-game combinations. Lexical analysis of 378,000 reasoning traces shows the mechanism is erosion of forward-looking intent rather than increased suspicion: long histories pull the model toward reasoning about past interactions rather than future payoffs. A LoRA adapter trained only on forward-looking traces mitigates the decay and transfers zero-shot to new games. Memory sanitization, which keeps prompt length fixed but swaps in synthetic cooperative records, restores cooperation, indicating the trigger is content rather than length. Ablating explicit chain-of-thought often reduces the collapse, suggesting deliberation amplifies the effect. The paper provides a diagnostic plus interventions for long-running agent systems where history quality, not just history length, drives behavior.

Paper | Tweet

10. Token Superposition Training

Nous Research’s second pretraining paper of the week. Token Superposition Training (TST) is a modification to the standard LLM pretraining loop that produces a 2 to 3x wall-clock speedup at matched FLOPs without changing the model architecture, optimizer, tokenizer, or training data. During the first third of training, the model reads and predicts contiguous bags of tokens, averaging their embeddings on the input side and predicting the next bag with a modified cross-entropy on the output side. For the remainder of the run, training reverts to standard next-token prediction. The inference-time model is identical to one produced by conventional pretraining. TST was validated at 270M, 600M, and 3B dense scales, and at a 10B-A1B mixture-of-experts model where it reaches a lower final loss while consuming 4,768 B200-GPU-hours versus the baseline’s 12,311. Together with Lighthouse Attention, this is the second pretraining-loop modification from the same lab this week reporting substantial speedups without architecture changes.

Paper | Tweet

🤖 AI Agents Weekly: Thinking Machines Interaction Models, Is Grep All You Need?, Codex Mobile + Hooks, Cursor Cloud Agents, Ring-2.6-1T, and More

Sat, 16 May 2026 15:01:48 GMT

In today’s issue:

Thinking Machines unveils interaction models
Is Grep All You Need? challenges vector RAG
OpenAI ships Codex mobile and hooks
Cursor adds cloud agent dev environments
Ring-2.6-1T open trillion-scale agent model
Recursive Superintelligence emerges with $650M
LangChain Labs targets continual learning
xAI launches Grok Build CLI
Claude Code adds agent view
Prime Intellect agents beat nanoGPT speedrun
World Labs open-sources image-blaster
Isomorphic Labs raises $2.1B Series B
Beyond Individual Intelligence multi-agent survey
LongMemEval-V2 raises the memory bar

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

🥇Top AI Papers of the Week

Sun, 10 May 2026 15:01:05 GMT

1. HeavySkill

One of the cleaner takes on agentic harness design released this year. The paper argues that what actually drives harness performance is not the orchestration code, but a single inner skill: parallel reasoning followed by deliberation. Internalize that pattern into the model and most of the surrounding scaffolding becomes optional. HeavySkill systematizes the idea as a two-stage pipeline you can run beneath any harness, then trains it as a learnable skill via RLVR. The result is a harness win that looks more like a model win.

Two-stage skill, not orchestration glue: Stage one runs parallel reasoning across multiple sampled chains. Stage two performs a deliberation pass that compares, critiques, and synthesizes those chains into a final answer. The pipeline is the same regardless of harness, which is why it transfers across tasks.
GPT-OSS-20B jumps from 69.7% to 85.5% on LiveCodeBench: Under the heavy-thinking variant (HM@4), the 20B model gets a 15.8 point lift on a hard coding benchmark. The same recipe takes R1-Distill-Qwen-32B from 35.7% to 69.3% on IFEval, nearly doubling its instruction-following score.
Pass@N-level performance from a learned skill: Several models reach Pass@N-level performance once HeavySkill is internalized through RLVR, which is the property that makes the parallel-deliberation pattern actually portable. The skill survives outside the harness it was trained under.
Why it matters: Harness wins start to look like model wins once you can train them in. If parallel reasoning plus deliberation really is the inner skill, the long arc is models that ship with it baked in, not orchestration glue layered around them.

Paper | Tweet

2. Conductor

Sakana AI’s ICLR 2026 paper introduces a 7B Conductor model that hits SOTA on GPQA-Diamond and LiveCodeBench by orchestrating other LLMs instead of solving problems itself. The Conductor is trained with RL to do two things simultaneously: design communication topologies between worker agents (open or closed source) and prompt-engineer focused instructions to each worker so it leverages individual strengths. The orchestrator becomes a learnable policy, not a wrapper around one.

Topology design plus targeted prompting: A single RL policy decides who talks to whom and what each worker is told. Trained against randomized agent pools, the Conductor adapts to arbitrary mixes of agents at inference time, including agents it never saw during training.
Recursive topologies emerge: When allowed to pick itself as a worker, the Conductor forms recursive topologies, unlocking a new form of dynamic test-time scaling through online iterative adaptation. Coordination becomes its own scaling axis, separate from model size or context length.
3% gains on AIME25 and GPQA-D from coordination alone: The gains over the best individual worker land in the 3% range, which the authors note is consistent with entire generational improvements between frontier model versions. The difference is that here the lift comes from learned routing, not from larger pretraining runs.
Why it matters: This is one of the cleaner arguments yet that the orchestrator should be the model. Routing decisions stop being a wrapper and become a learnable policy, which is the right abstraction for production agent stacks that compose multiple model providers.

Paper | Tweet

3. Self-Improving Pretraining

Most LLM safety, factuality, and reasoning fixes get bolted on at post-training. By then the patterns have already set. This Meta FAIR paper moves those behaviors into pretraining itself. The team uses a strong post-trained model as both a rewriter and a judge: it rewrites pretraining suffixes toward higher-quality, safer continuations, then scores model rollouts against the original suffix and the rewrite to drive RL during pretraining. Instead of next-token prediction, the policy learns sequence generation from the start, with rewards for quality, safety, and factuality.

Post-trained model as rewriter and judge: The strong model rewrites suffixes during pretraining, then judges rollouts of the in-training model against both the rewrite and the original. Safety, factuality, and quality become reward signals rather than post-hoc filters, which lets the policy internalize the targets early.
Sequence generation from the start: The policy is trained to generate sequences directly under reward, not to predict the next token. This shifts the inductive bias toward producing the kinds of continuations the judge rewards, which matters most on long-form generation where token-level losses lose discriminative signal.
Concrete gains across the board: 36.2% relative gain in factuality, 18.5% in safety, and up to 86.3% win rate in generation quality over standard pretraining. The safety and factuality numbers are large enough to suggest these properties are easier to install during pretraining than to retrofit after the fact.
Why it matters: The post-trained models you already have can be used to pretrain the next ones better. That is a recursive improvement loop at the pretraining layer, which is where the largest behavioral commitments actually get locked in.

Paper | Tweet

4. Connect Four AlphaZero from Scratch

This paper proposes a new way to evaluate coding agents: hand them a minimal task description, give them a tight budget, and ask them to autonomously rebuild a famous ML breakthrough end-to-end. Connect Four plus AlphaZero is the first instance. It is small enough to run on a laptop and hard enough to require a real research engineering loop. Claude Opus 4.7 implemented the full pipeline (MCTS, neural value and policy nets, self-play, training schedule) in three hours on consumer hardware, then beat the Pascal Pons solver 7 of 8 as first-mover. No other frontier coding agent tested cleared 2 of 8.

From patches to systems: Existing coding-agent benchmarks measure unit-test fixes and small patches. This benchmark measures whether the agent can build a non-trivial ML system from a one-paragraph spec, which is closer to what production research engineering actually looks like.
Tight budget, real research loop: The agent has to design the search algorithm, train the networks, schedule self-play, and debug the loop, all within a fixed compute budget on consumer hardware. There is no escape hatch into a pre-built library, which is what makes the task discriminative.
A clean separation between frontier coders: Claude Opus 4.7 reached 7 of 8 wins as first-mover against the Pascal Pons solver. No other frontier coding agent tested cleared 2 of 8. The gap is large enough to suggest the benchmark is detecting something real about end-to-end ML engineering capability.
Why it matters: Patch-style benchmarks are starting to saturate. Rebuild-a-breakthrough tasks give the field a harder ceiling to push against, and they map more directly to the agent workloads people actually want to deploy.

Paper | Tweet

Message from the Editor

Excited to announce our new on-demand course “Vibe Coding AI Apps with Claude Code“. Learn how to leverage Claude Code features to vibecode production-grade AI-powered apps.

Enroll Now

5. Coordination as Architecture

Multi-agent LLM systems fail in production at rates between 41% and 87%, and the majority of those failures are coordination defects, not base-model capability. Most published comparisons of multi-agent architectures cannot even tell you whether the gain came from coordination or from one configuration just having more context. This paper argues coordination should be treated as a configurable architectural layer, separable from agent logic and information access, then backs the position with an information-controlled experiment.

Information-controlled methodology: Same LLM, same tools, same prompt template, same per-call output cap. The only thing that varies is coordination structure. Once information access is held constant, the actual contribution of coordination becomes measurable for the first time.
Coordination as a separate layer: The paper proposes treating coordination structure (who talks to whom, when, with what aggregation rule) as a first-class architectural axis. That separation lets teams reason about coordination changes without re-running the entire stack.
A vocabulary for the field: Until now, “multi-agent beats single-agent” comparisons have been confounded by context-window asymmetries. This paper provides the methodology and vocabulary needed to actually test coordination claims, which is overdue infrastructure for the multi-agent research line.
Why it matters: If 41% to 87% of failures are coordination defects, fixing coordination is the highest-leverage thing builders can do. The paper turns that intuition into a measurable engineering target instead of a vibes-based debate.

Paper | Tweet

6. Horizon Generalization

Microsoft Research runs a controlled study where the only variable is task horizon length. Same decision rules, same reasoning structure, different sequence length to the goal. The main finding: horizon alone is a training bottleneck. As goal distance grows, exploration explodes combinatorially and credit assignment gets ambiguous. Models that learn cleanly on short horizons fall apart on long ones, even when the underlying reasoning is identical. The fix is not more compute, it is horizon reduction.

Horizon as a first-class variable: By holding decision rules and reasoning constant and only varying sequence length, the paper isolates horizon as a distinct training bottleneck. This separates “the agent cannot reason” from “the agent cannot stitch together long sequences,” which most prior work conflated.
Macro actions stabilize training: Re-parameterizing the action space with macro actions that compress many low-level decisions into one stabilizes training immediately. The agent learns the same task, just at a coarser temporal grain that keeps credit assignment tractable.
Generalization to longer horizons at inference: Models trained on reduced horizons generalize to longer ones at inference time. The paper calls this horizon generalization, and it is the most useful property because it means you can train cheap and deploy long.
Why it matters: Most teams treat long-horizon failures as a model-capacity problem. This paper says it is a horizon problem. Reduce horizon during training, get stability now and generalization for free at inference, without retraining a larger backbone.

Paper | Tweet

7. 1,000 Synthetic Computers

Microsoft Research builds 1,000 synthetic computers, each with realistic directory structures, documents, and artifacts, then runs long-horizon simulations on top of them. One agent plays the user and sets productivity goals; another executes the work. Each simulation runs over 8 hours of agent runtime and 2,000+ turns on average, roughly a month of human work compressed into one trace. Training on this experiential data drives significant improvements on both in-domain and out-of-domain productivity evaluations.

Realistic synthetic environments: Each of the 1,000 computers ships with directory structures, documents, and artifacts that approximate a real user’s working environment. The realism is what makes the trajectories useful as training data instead of as evaluation curiosities.
Two-agent simulation loop: A user agent sets productivity goals while a worker agent executes against them. The structure produces multi-turn, goal-directed traces that look like real productivity work, not the short scripted tasks that dominate existing benchmarks.
Designed to scale to billions of worlds: The framework is explicitly designed to scale to millions or billions of synthetic user worlds, which matches the scale at which frontier computer-use agents will need experiential data. The bottleneck on long-horizon training is data, and this is a credible recipe for producing it.
Why it matters: The bottleneck on computer-use agents has stopped being model capability and become realistic long-horizon training data. Synthetic-environment scaling is one of the few paths that does not depend on collecting massive amounts of real user telemetry, which makes it a practical default for teams building computer-use stacks.

Paper | Tweet

8. Contextual Agentic Memory is a Memo

Most agent memory today is not memory, it is closer to a memo. Vector stores, RAG buffers, and scratchpads implement lookup, not consolidation. The paper draws on neuroscience’s Complementary Learning Systems theory: biological intelligence pairs fast hippocampal storage with slow neocortical consolidation, and current AI agents only implement the first half (fast write, similarity recall, no abstraction step). The authors prove a generalization ceiling on compositionally novel tasks: as long as memory stays retrieval-only, the agent cannot apply abstract rules to inputs that do not already look like something in the store, and it remains permanently exposed to memory poisoning. If you are building long-running agents and treating memory as a vector index, this paper is a clean diagnosis of what you are missing.

Paper | Tweet

9. Agentic-imodels

The entire interpretability literature is built around human readers. As more analysis gets delegated to agents, the right target of interpretability shifts. Microsoft Research introduces Agentic-imodels, an autoresearch loop where a coding agent (Claude Code, Codex) iteratively evolves scikit-learn-compatible regressors that are simultaneously accurate AND readable by other LLMs. Interpretability is measured by whether a small LLM can simulate the fitted model’s behavior just by reading its string representation, predictions, feature effects, and counterfactuals from the str output alone. Across 65 tabular datasets, the discovered models push the Pareto frontier past every classical interpretable baseline (decision trees, GAMs, sparse linear), and improve four downstream agentic data-science systems on the BLADE benchmark by 8% to 73%.

Paper | Tweet

10. Skills as Verifiable Artifacts

If you ship agent skills, your runtime is treating signed-and-cleared skills as trusted by default. This paper argues a skill is untrusted code until it is verified, and the runtime should enforce that default rather than infer trust from origin. Without skill verification, HITL has to fire on every irreversible call, which degrades into rubber-stamping at any non-trivial scale. With verification as a separate gated process, HITL fires only for what is unverified. Skills are now first-class deployment artifacts, and we have decades of supply-chain lessons on what happens when trust is inferred from a signature. This is the right ask for SKILL.md before agent skill libraries become the next attack surface.

Paper | Tweet

🤖 AI Agents Weekly: Meta FAIR Autodata, ZAYA1-8B, SubQ 12M Context, Natural Language Autoencoders, Claude Managed Agents Dreaming, and More

Sat, 09 May 2026 15:01:49 GMT

In today’s issue:

Meta FAIR introduces Autodata
Zyphra releases ZAYA1-8B
SubQ ships a 12M-token frontier model
Anthropic introduces Natural Language Autoencoders
Claude Managed Agents adds dreaming and multi-agent
Printing Press: an agent CLI factory
Flue agent harness framework launches
Anthropic adds keyless auth
AlphaEvolve marks one year of impact
Goodfire opens a neural geometry series
Firefox hardened with Claude Mythos

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

🥇Top AI Papers of the Week

Sun, 03 May 2026 15:02:56 GMT

1. Agentic Harness Engineering

Most coding-agent harnesses are still tuned by hand or kept alive through brittle trial-and-error self-evolution. This paper introduces Agentic Harness Engineering (AHE), a framework that makes harness evolution observable and falsifiable. AHE separates the system into three layers: components stored as revertible files, experience condensed from millions of trajectory tokens into structured evidence, and decisions written as predictions that get checked against task outcomes. Every edit becomes a contract you can verify or revert.

Three-layer evolution model: Components, experience, and decisions are each first-class artifacts. Components are versioned files, experience is compressed evidence pulled from full trajectory logs, and decisions are explicit hypotheses with expected outcomes. The structure turns black-box harness tuning into an auditable engineering loop.
Pass@1 gains on Terminal-Bench 2: Pass@1 climbs from 69.7% to 77.0% across ten iterations, beating both human-designed Codex-CLI (71.9%) and self-evolving baselines like ACE and TF-GRPO. The framework also uses 12% fewer tokens than the seed harness on SWE-bench-verified.
Cross-model transfer: The evolved harness transfers across model families with +5.1 to +10.1 point gains, suggesting the optimizations are structural rather than overfit to a specific backbone. That is the property you actually want from harness engineering.
Why it matters: Harness work is the largest hidden cost in most agent systems. AHE is the first credible recipe for letting the harness improve itself without drifting into noise, which makes it the most important agent-systems paper of the week.

Paper | Tweet

Message from our Sponsor

Kurate.org - Arena for scientific papers. Every day, hundreds of arXiv preprints are ranked by scientific impact through pairwise tournaments judged by Claude, GPT and Gemini models. See the top ranked papers in AI, ML, Robotics, Quantum Physics, and more for free.

Explore The Leaderboards

2. AgenticQwen-30B-A3B

Alibaba shows that a 30B MoE model with only 3B active parameters can match Qwen3-235B on real tool-use workloads. AgenticQwen-30B-A3B scores 50.2 average on TAU-2 plus BFCL-V4 Multi-Turn, while AgenticQwen-8B scores 47.4. Both more than double their vanilla Qwen baselines and close most of the gap to a 235B model. The recipe is built around two reinforcement learning flywheels that run in parallel, with simulated users actively trying to mislead the agent.

Reasoning flywheel from self-failure: The first loop mines the model’s own errors and converts them into harder reasoning problems each round. The training distribution gets harder on its own as the model improves, removing the need for new human-curated reasoning data.
Agentic flywheel for tool use: The second loop grows simple linear tool-use trajectories into multi-branch behavior trees. Simulated users test recovery from misleading instructions, ambiguous goals, and failed tool calls, which is where vanilla supervised tuning typically breaks.
Real efficiency for production agents: A 30B MoE with 3B active tokens at inference is significantly cheaper to serve than a 235B dense or MoE alternative. For tool-use workloads where frontier reasoning is overkill, this changes the cost profile of shipping production agents.
A reusable recipe: The flywheel approach generalizes beyond Qwen. Teams can generate hard examples from their own agent’s failures rather than relying on static synthetic data, which is the more scalable path for domain-specific agents.

Paper | Tweet

3. Agentic World Modeling

A massive 40-author survey lands the cleanest taxonomy of world models in agent research released so far. The paper proposes a “levels by laws” framework spanning three capability levels and four law regimes, then synthesizes 400+ works and 100+ representative systems across model-based RL, video generation, web and GUI agents, multi-agent simulation, and scientific discovery. As agents shift from chatbots to goal-accomplishers, the bottleneck moves from language to environment, and this is the first paper that gives builders a shared vocabulary across communities that have been working in isolation.

Three capability levels: L1 Predictors handle one-step transitions, L2 Simulators do multi-step action-conditioned rollouts, and L3 Evolvers self-revise as the world changes. The hierarchy makes it easy to place existing systems and identify where capability gaps actually live.
Four law regimes: Physical, digital, social, and scientific laws each impose different constraints on what a world model needs to capture. The framework treats them as orthogonal axes, which clarifies why a strong physics simulator can still fail at social or digital tasks.
Failure-mode catalog: The survey extracts recurring failure patterns across 100+ systems, including misaligned reward shaping, drift under non-stationarity, and brittle transfer across regimes. Each failure mode is mapped to a level and law combination, so the diagnosis is grounded.
Evaluation principles per level: The authors propose evaluation criteria specific to each capability level rather than a single benchmark. This is the right move because L1 prediction accuracy and L3 self-revision quality are not measurable on the same axis.

Paper | Tweet

4. RecursiveMAS

Multi-agent systems usually pass full text messages between agents at every step, which causes token bloat, latency, and context dilution that all grow with team size. RecursiveMAS asks a different question: what if agents collaborated through recursive computation in a shared latent space instead of through text? The system treats a multi-agent team as a recursive computation where each agent acts like an RLM layer, iteratively passing latent representations to the next and forming a looped interaction process. Less talking, more thinking.

RecursiveLink for latent communication: A RecursiveLink module generates latent thoughts and transfers state directly between heterogeneous agents, replacing natural-language messages with internal representations. The change removes the cost of re-encoding and re-parsing text on every coordination step.
Inner-outer loop learning: The training algorithm uses an inner loop for per-step latent updates and an outer loop for team-level credit assignment, with shared gradient-based updates across agents. This makes joint optimization tractable instead of relying on hand-tuned communication protocols.
Strong gains across 9 benchmarks: Across math, science, medicine, search, and code generation, RecursiveMAS delivers 8.3% average accuracy gain over baselines, 1.2x to 2.4x end-to-end inference speedup, and 34.6% to 75.6% reduction in token usage. The efficiency story is at least as important as the accuracy story.
A path past the agent communication tax: If agent-to-agent communication is the next real bottleneck, latent-space recursion is one of the cleaner ways to scale collaboration. Teams running multi-agent systems at scale should treat this as a serious design alternative, not a research curiosity.

Paper | Tweet

5. OneManCompany

If you are building multi-agent systems, you are probably wiring static org charts. This paper argues they should look more like a labor market. OneManCompany (OMC) replaces fixed teams with “Talents,” portable agent identities that bundle skills and tools, and a “Talent Market” where agents get recruited dynamically per task. An Explore-Execute-Review tree search decomposes work hierarchically and aggregates results back up. On PRDBench, OMC reaches 84.67% success, +15.5 points over prior SOTA, and the framework generalizes across the case studies the authors run.

Talents as portable identities: A Talent bundles a skill set, tool access, and behavioral priors into a reusable agent identity. Talents can be hired into any task without rewiring the orchestration graph, which removes most of the brittleness in pre-wired multi-agent pipelines.
Dynamic recruitment via Talent Market: Tasks post requirements, and the market matches Talents to roles based on capability fit and current load. This replaces the standard “design a team for every workflow” pattern with on-demand assembly that adapts as the task population shifts.
Explore-Execute-Review tree search: Work is decomposed top-down into subtasks, executed in parallel by recruited Talents, then reviewed and aggregated up the tree. The structure naturally supports retries, branching, and cross-checking without manual coordination logic.
Why it matters: Pre-wired multi-agent pipelines break the moment tasks drift outside their design envelope. Treating agents as a recruitable workforce gets you self-organization and continuous improvement by default, which is what open-ended agent systems need.

Paper | Tweet

6. From Skill Text to Skill Structure

SKILL.md files entangle invocation interface, execution flow, and tool side effects in a single blob of natural language. That makes downstream discovery and risk review brittle as skill registries scale. This paper proposes SSL, a three-layer typed JSON representation drawn from Schank and Abelson’s classical work on scripts, MOPs, and conceptual dependency. An LLM-based normalizer converts existing SKILL.md files into the structure, so adoption does not require rewriting registries by hand.

Three layers, cleanly separated: A Scheduling layer captures invocation signals and trigger conditions, a Structural layer encodes execution scenes and ordering, and a Logical layer specifies atomic actions plus resource and side-effect annotations. The separation lets discovery, risk, and execution each reason about the layer they care about.
Skill Discovery MRR jumps 0.573 to 0.707: Treating skills as typed structure rather than prose makes retrieval significantly more accurate, even before any model fine-tuning. The gain comes from the structure exposing what skills actually do, not just how they describe themselves.
Risk Assessment macro F1 of 0.787: The Logical layer’s resource annotations enable a 0.744 to 0.787 jump in risk classification. Auditors can now reason about side effects directly instead of inferring them from free-form prose.
A 6,184-skill corpus released: The authors ship a normalized corpus of 6,184 skills, 403 task queries, and 500 risk-labeled skills. As skill registries cross a million entries, structured representations are the only path that keeps discovery and review tractable.

Paper | Tweet

7. Latent Agents

Multi-agent debate makes models reason better. It also burns tokens generating long transcripts before any answer comes out. Latent Agents distills the entire debate into a single LLM through a two-stage fine-tuning pipeline: the model first learns debate structure, then internalizes it through dynamic reward scheduling and length clipping. The internalized model matches or beats explicit multi-agent debate while using up to 93% fewer tokens, which makes debate-quality reasoning practical at production scale.

Two-stage internalization pipeline: Stage one teaches the structure of debate (turn taking, critique, revision) through supervised fine-tuning on transcript data. Stage two uses dynamic reward scheduling and length clipping to compress that structure into single-pass reasoning without losing the gains from the multi-agent setup.
Up to 93% token savings: The internalized model matches or beats explicit debate accuracy while drastically reducing inference cost. For teams running reasoning workloads at scale, this is the kind of efficiency win that turns a research idea into a deployment default.
Activation steering reveals agent subspaces: The “agents” survive distillation as identifiable circuits in activation space. Probing finds interpretable directions corresponding to different agent perspectives, which means the internal structure persists even when the external transcript is gone.
A safety angle worth noting: When malicious agents are deliberately embedded via distillation, negative steering suppresses them more cleanly than steering a base model would, with smaller hits to general performance. Internalized debate may turn out to be a useful interpretability and alignment substrate, not just a token-saver.

Paper | Tweet

8. OCR-Memory

Most agent memory systems compress trajectories into text summaries and hope the model remembers what matters, which is exactly where the information loss hides. OCR-Memory renders the agent’s interaction history as images with indexed visual anchors, then retrieves via a locate-and-transcribe pipeline: the model scans visual memory, predicts the index of the relevant region, and the original text is fetched verbatim from a database. Older trajectories are stored as low-resolution thumbnails with active-recall up-sampling, and the method reaches SOTA on Mind2Web and AppWorld under strict context limits.

Paper | Tweet

9. When to Retrieve During Reasoning

Most RAG systems retrieve once, before the model starts reasoning. Large reasoning models like o1 and R1 do not work that way. They generate 12k to 25k token chains of thought and hit knowledge gaps mid-inference, long after the retrieval window closed. ReaLM-Retrieve is a reasoning-aware retrieval framework that injects evidence during multi-step inference, detects uncertainty at reasoning-step granularity, and learns a policy for when external evidence actually helps. It achieves +10.1% absolute F1 over standard RAG across MuSiQue, HotpotQA, and 2WikiMultiHopQA, with 47% fewer retrieval calls than fixed-interval IRCoT, and hits 71.2% F1 on 2-4 hop MuSiQue with only 1.8 retrieval calls per question.

Paper | Tweet

10. Co-evolving Decisions and Skills

Long-horizon agents fail in two ways: the decision-maker cannot decompose well, or the skill library goes stale. This paper introduces a co-evolution framework where an LLM decision agent and a dynamic skill bank improve each other through iterative refinement. The decision agent picks and chains skills, performance feedback updates both the policy and the skills, and new skills emerge by generalizing successful sequences instead of being hand-coded upfront. Most long-horizon agent stacks treat skills and decision-making as separate optimization problems, which is why they plateau. Co-evolution gives you adaptive planning and a growing library of reusable behaviors from a single loop, which is what you actually want when task structure is not predetermined: robotics, game agents, and complex planning.

Paper | Tweet

AI Newsletter

🥇Top AI Papers of the Week

1. Red Queen Gödel Machine

Message From Our Sponsor

2. MCP Server Patterns

3. The Verification Horizon

4. Paper Assistant Tool

5. Generative Skill Composition

6. AutoMem

7. RLMF

8. ASPIRE

9. HORIZON

10. Reasoning Quality Emerges Early

🤖 AI Agents Weekly: Claude Sonnet 5, Grok Voice Agent Builder, LongCat-2.0, Hosted X MCP, Cursor for iOS, Claude Science, and More

Top Stories

Anthropic Launches Claude Sonnet 5

xAI Launches Grok Voice Agent Builder

🥇Top AI Papers of the Week

1. Sakana Fugu

2. Agent-Native Memory

3. Autodata

4. Critique of the Agent Model

Message from the Editor

5. Agent-as-a-Router

6. Agent Communication Protocols

7. A Pinch of Human Data

8. Skill-MAS

9. Reliability without Validity

10. NatureBench

🤖 AI Agents Weekly: GPT-5.6, Ornith-1.0, Codex Inside OpenAI, Claude Tag, Qwen-AgentWorld, AI SDK 7, and More

Top Stories

OpenAI Previews GPT-5.6

🥇Top AI Papers of the Week

1. SpatialClaw

Message from the Editor

2. Compositional Skill Routing

3. PreAct

4. Can LLM Agents Infer World Models?

5. From Trainee to Trainer

6. OpenClaw-Skill

7. Back on Track

8. AtomMem

9. Beyond Domains

10. The Stanford EDGAR Filings Dataset

🤖 AI Agents Weekly: GLM-5.2, Claude Code Artifacts, Qwen-Robot Suite, Codex Skills, Block's Builderbot, SpatialClaw, and More

Top Stories

Z.ai Open-Sources GLM-5.2, a Frontier Model with a 1M-Token Context

Omnigent Is an Open-Source Meta-Harness for All Your AI Agents

Autonomous Long-Running Coding Agents

From Prompting to Goal Design

The Evaluator Becomes a First-Class Component

Verifiers Define the Boundary of Trust

Loops Make Autonomy Durable

Planning Is Where Expertise Enters

Visual Artifacts Become Control Surfaces

Session Mining Turns Usage Into Memory

A Practical Operating Model

What Still Breaks

🥇Top AI Papers of the Week

1. MiniMax Sparse Attention

Message from the Editor

2. Self-Harness

3. Agents’ Last Exam

4. How AI Agents Reshape Knowledge Work

5. Agentopia

6. The Geometry of On-Policy Distillation

7. Lookahead Sparse Attention

8. Latent Spatial Memory

9. The Consistency Illusion

10. Beyond Scalar Rewards

🤖 AI Agents Weekly: Claude Fable 5, Kimi K2.7-Code, NotebookLM Goes Agentic, DiffusionGemma, MiMo Code, and More

Top Stories

Anthropic Launches Claude Fable 5, Its First Public Mythos-Class Model

🥇Top AI Papers of the Week

1. Self-Revising Discovery Systems

2. Disentangling Agent Self-Evolution

3. LEAP

4. Scaling Laws for Agent Harnesses

Message from the Editor

5. AutoLab