AI Newsletter

🥇Top AI Papers of the Week

Sun, 06 Sep 2026 15:04:17 GMT

1. Declarative Attention

A model reads its entire KV cache on every generated token, even though it ends up attending to a tiny slice of it. Ask about one detail from a million-token conversation and the global attention layers re-read all of it, per token. Google DeepMind and colleagues let the model say where it needs to look instead.

The declaration lives in the chain-of-thought: Generation splits into three modes. Global reads the full context, focus reads one specific region, and local reads only recent output. The model emits those tags in its own reasoning, so nothing about the weights changes.
The inference engine treats it like a tool call: It parses the declarations the same way it parses function calls and skips most of the cache read. The usual alternative guesses at relevant tokens with cheap proxy scores, which still costs O(N) at every step.
Zero-shot on off-the-shelf weights: Across 15 long-context tasks, attended tokens during decoding drop 52.0% on Gemma-4-31B and 31.1% on Qwen-3.6-27B, at a 1 to 3 point average accuracy cost.
Why it matters: Long-context serving costs are a structural problem for anyone running agents over large repositories or long conversations. Handing the routing decision to the model, in the text it already produces, is a cheaper fix than another retrieval layer bolted on top.

Paper | Tweet

2. Harness-of-Harness

Coding agents are good for a session and unreliable for a week. Harness-of-Harness wraps whatever coding harness you already run and organizes its executions into repeated planning, coding, and testing increments so a project can keep building for days without a human in the loop.

Three roles around one artifact: A Project Planner turns the spec and the accumulated test evidence into a new development plan, a Developer builds against that plan, and a QA Tester evaluates the result across quality dimensions and returns an evidence bundle. The next iteration starts from that bundle rather than from a transcript.
Testing gets split in two: Implementation-time testing stays separate from independent evaluation, which keeps the agent from grading its own work with the same tests it wrote to pass.
Constraints sit on the outputs: The loop balances repair against capability growth and scopes work into small verifiable steps, so a long run does not stall on one broken subsystem or wander into unplanned features.
Why it matters: Across GameCraft-Bench, FrontierSWE, and ProgramBench with three different harness and model pairs, it averages a 52.25% relative gain over the standalone harnesses after three iterations, peaking at 82.86%. Since it sits on top of an existing harness, the pattern is portable to whatever you already run.

Paper | Tweet

3. WikiSkill

Karpathy popularized the idea of an LLM wiki. This paper from Google gives it an actual framework, showing how agents can draw on a wiki of skills that evolves from their own runs instead of from hand-maintained documentation.

Three layers with different write rules: Immutable execution traces are written once and never edited. A wiki layer of structured patterns and evolution logs compounds and never resets. A skill layer sits on top and gets reversible, conditional updates.
The loop closes on failures: An inference agent executes rollouts, a wiki maintainer runs root-cause analysis on the traces, a skill proposer drafts updates from the wiki and the traces, and a gating step evaluates the candidate on a validation set before anything ships. Bad updates roll back.
Evolved skills transfer: The method is model-agnostic, and skills evolved on one model carry over to smaller models that sometimes outperform bigger ones running without skills.
Why it matters: Most teams maintain skills by hand and discover the gaps in production. WikiSkill turns agent runs into the maintenance signal, and the practical takeaway generalizes past the paper. Build a persistent knowledge base across your projects, then use it to keep skills tuned.

Paper | Tweet

4. SKILL.state

Long-running agents slow down and start poisoning their own context, and both symptoms trace back to one design choice. Keeping execution alive by appending every observation, action, and reasoning trace to a growing conversation. Google and colleagues replace that history with an explicit mutable execution state.

The prompt stops growing: At each step, the model sees only the immutable skill specification, the current structured state, and the latest observation. Prompt size goes from O(T) in the number of steps to O(1).
Reasoning is discarded on purpose: Intermediate reasoning gets thrown away the moment it produces a validated state update, expressed as a JSON patch. What survives is the state, not the narration that produced it.
Accuracy and cost move together: Across several datasets, models, and execution environments, task accuracy improves while cumulative token consumption drops. Baseline runtimes hit quadratic context growth on long-horizon warehouse tasks where SKILL.state stays bounded.
Why it matters: The abstraction is architecture-agnostic and ports into existing skill runtimes, so this is closer to a change you can make than a system you have to adopt. If your agent degrades past a few hundred steps, this names the reason.

Paper | Tweet

Message from the Editor

We just released Write better with Claude Fable 5.1, a hands-on DAIR Academy lab on getting better prose out of the model. Free for a limited time.

Get Started

5. CORAL

Meta ran an agent harness against a live production recommender serving billions of people and reported A/B results. Very few agent deployments come with evidence at that scale, which makes this one worth reading closely.

Continual optimization is the job: Sustaining a recommender means revisiting retrieval, ranking, and serving choices as content, user behavior, and upstream models shift. Human engineers test those changes through online experiments, which is slow enough that parts of the system go unrevised for long stretches.
The loop is observe, reason, optimize, measure: Each cycle the agent reads operating signals, reasons over a memory of past decisions and their measured outcomes, then invokes tools including a numerical optimizer. The policy improves in context from its own prior actions with no parameter updates.
Guardrails carry as much weight as the agent: A constrained optimizer holds every change inside a fixed operating budget before anything deploys. The bounded change budget is why this can run against production at all.
Why it matters: Across two large social platforms, the same harness improved engagement at no additional serving cost on one and reduced serving cost without degrading engagement on the other, with performance improving as the loop iterated. The guardrail design transfers to other domains more readily than the recommender specifics do.

Paper | Tweet

6. E-Commerce Bench

Agent benchmarks usually end when the session does. The Qwen team built one that runs an agent through a simulated 365-day year operating several online stores at once, then scored 18 frontier models on seven dimensions.

Four layers under the agent: An agent loop layer handles turn-based control, context management, and persistent memory. A tool layer covers store operations, supplier negotiation, inventory, and finance. An environment layer runs a dynamic economy with seasonality, promotions, disasters, and supplier bankruptcies. A data layer supplies 12 store types, 576 suppliers, and 6,886 products.
No model dominates: GPT-5.6 Sol earns the most, growing a 100,000 opening stake into 1,431,425, then ranks 16th of 18 on fraud avoidance and trails Fable 5 on operational efficiency. Profit and judgment come apart.
Open weights hold up: Qwen3.8-Max-Preview leads the open-weight field at 416,252, 38% above GLM 5.2 (high), and shows the strongest learning over the horizon by progressively bargaining suppliers down across repeated orders.
Why it matters: A year-long simulation surfaces failure modes a single-session eval cannot reach, including the slow ones around fraud exposure and margin discipline. If you evaluate agents on anything longer than one session, the scoring design here is the useful part.

Paper | Tweet

7. AI Research Preference Models

A research agent can propose far more experiments than it can afford to run, so idea generation was never the bottleneck. Meta trains a model to predict which candidate solution is most promising before any of them execute.

Two variants on frozen backbones: An inference-only model reasons over candidate plans, code, and previously executed solutions in the search tree. An agentic model goes further and runs small-scale pilot experiments before committing budget to a candidate.
It slots into the search loop: At each node, the agent generates candidate mutations, the preference model picks the child to expand, and the tree updates from the result. Nothing about the underlying agent changes.
Less time and less compute: Both variants reach the unguided agent’s 24-hour performance in roughly 15 hours using less than two-thirds of its execution budget, and average normalized score on AIRS-Bench moves from 0.684 to 0.711 and 0.729.
Why it matters: Once compute is the binding constraint on a research agent, deciding what not to run matters as much as running well. The same selection pattern applies to any agent choosing among expensive branches, not only ML research.

Paper | Tweet

8. Trace as State

Where you put a reasoning trace changes long-context accuracy by up to 50 points. Transformers process causally, so a task state discovered late cannot guide reading that already happened, and Trace as State puts the collected trace before the long-context block on a fresh pass instead of appending it after. On GraphWalks Parents, DeepSeek V4 Pro Preview goes from 29.2% on the initial pass and 43.0% with the matched append control to 81.8%, and GLM-5.2 goes from 66.4% and 83.2% to 100.0%. It wins in 26 of 27 reported combinations of model, task, and metric with no architecture change.

Paper | Tweet

9. Selective Forgetting

Graph memory is widely assumed to beat flat retrieval for long-term agents, and this paper tests it with the candidate-generation budget held fixed at five retrieval roots. On LongMemEval, the graph scores token F1 0.42 against 0.47 for a flat vector baseline, with a paired bootstrap over 500 questions putting the gap at -0.050. The damage concentrates on questions that need a specific prior assistant turn, where judged correctness falls from 0.911 to 0.607, because splitting a turn into entities discards the surface form. The forgetting module fares much better, pruning 9.8% of nodes from a persistent 27,021-node graph with token F1 unchanged.

Paper | Tweet

10. Runtime-Independent Persistent Agents

We describe an agent by whatever model and harness it happens to run on, which works for one session and says very little about an agent running for months across a new model, a new harness, or a new machine. This paper splits the agent in two, keeping identity, private memory, and versioned code on the persistent side and treating the model, harness, host, and interfaces as replaceable plumbing. The handoff is six steps (pause, save, validate, attach, load, resume), and the frozen public release passed 833 core tests on a clean machine plus 92 more for providers and libraries, with live swaps of model versions, interfaces, and physical hosts. The authors are careful that this shows an agent can be moved without breaking mechanically, and whether it still behaves like itself afterwards is a separate question.

Paper | Tweet

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

Sat, 05 Sep 2026 15:36:27 GMT

In today’s issue:

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

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

🥇Top AI Papers of the Week

Sun, 30 Aug 2026 15:19:03 GMT

1. Judges as a Lifecycle

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

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

Paper | Tweet

2. Skill Lift

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

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

Paper | Tweet

3. Context Management as Code

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

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

Paper | Tweet

4. JIT-Agent

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

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

Paper | Tweet

Message from the Editor

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

Get Started

5. Prime Agent

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

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

Paper | Tweet

6. What Compaction Destroys

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

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

Paper | Tweet

7. Co-Scientist in Real Labs

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

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

Paper | Tweet

8. Recuris

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

Paper | Tweet

9. Meta^n

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

Paper | Tweet

10. EvoMal

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

Paper | Tweet

🤖 AI Agents Weekly: GLM-5.3-Flash, Hy4 Preview, Qwen3.8-Flash, Claude's Built-In Browser, Terminal-Bench-Science, Jalapeño, Skild S1, and More

Sat, 29 Aug 2026 15:33:13 GMT

In today’s issue:

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

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

🥇Top AI Papers of the Week

Sun, 23 Aug 2026 15:44:05 GMT

1. Agent Lightning v1.0

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

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

Paper | Tweet

2. The Skill Trigger Bottleneck

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

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

Paper | Tweet

3. Harness-Level Forgetting

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

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

Paper | Tweet

4. The Control-Plane Tax

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

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

Paper | Tweet

Message from the Editor

Enroll Now

5. Demystifying Agent Skills

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

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

Paper | Tweet

6. Strategy Lock-In

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

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

Paper | Tweet

7. SocialRL

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

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

Paper | Tweet

8. ClawGym II

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

Paper | Tweet

9. Inside an Agent Team

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

Paper | Tweet

10. Fragile Self-Improvement

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

Paper | Tweet

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

Sat, 22 Aug 2026 15:22:20 GMT

In today’s issue:

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

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

🥇Top AI Papers of the Week

Sun, 16 Aug 2026 16:23:34 GMT

1. Skaling

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

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

Paper | Tweet

2. Stealing Reasoning Traces

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

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

Paper | Tweet

3. Mind Viruses

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

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

Paper | Tweet

4. Catastrophic Remembering

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

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

Paper | Tweet

Message from the Editor

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

Get Started

5. Programmatic Tool Calling

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

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

Paper | Tweet

6. Distilled Reasoning Skills

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

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

Paper | Tweet

7. Harness-IF

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

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

Paper | Tweet

8. Lost in Compaction

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

Paper | Tweet

9. Cracks in the Foundation

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

Paper | Tweet

10. CEDAR

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

Paper | Tweet

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

Sat, 15 Aug 2026 16:43:19 GMT

In today’s issue:

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

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

🥇Top AI Papers of the Week

Sun, 09 Aug 2026 16:59:37 GMT

1. Model or Harness

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

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

Paper | Tweet

Message from the Editor

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

Get Started

2. Zero-Mem

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

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

Paper | Tweet

3. Sample More Reflect Less

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

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

Paper | Tweet

4. Harness-R1

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

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

Paper | Tweet

5. DataSpace

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

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

Paper | Tweet

6. Prompt-Induced Waste

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

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

Paper | Tweet

7. Rehearse

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

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

Paper | Tweet

8. ContinualSkillBench

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

Paper | Tweet

9. MerchantBench

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

Paper | Tweet

10. TokTier

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

Paper | Tweet

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

Sat, 08 Aug 2026 14:56:44 GMT

In today’s issue:

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

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

🥇Top AI Papers of the Week

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

1. NOOA

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

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

Paper | Tweet

Message from our Sponsor

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

Paste this into Claude Code, Codex, or Cursor:

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

Give your agent a phone number

2. ReOPD

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

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

Paper | Tweet

3. Invisible Reasoning

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

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

Paper | Tweet

4. Molt

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

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

Paper | Tweet

5. JAXBench

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

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

Paper | Tweet

6. ACM

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

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

Paper | Tweet

7. Filesystem Memory Audited

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

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

Paper | Tweet

8. Beyond AdamW

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

Paper | Tweet

9. Role Drift

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

Paper | Tweet

10. The Self-Speculating Agent

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

Paper | Tweet

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

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

In today's issue:

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

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

🥇Top AI Papers of the Week

Sun, 26 Jul 2026 17:48:49 GMT

1. Harness Handbook

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

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

Paper | Tweet

Message from the Editor

Get Started

2. From Memory to Skills

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

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

Paper | Tweet

3. PRO-LONG

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

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

Paper | Tweet

4. Global Workspace in LLMs

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

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

Paper | Tweet

5. GAMUT

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

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

Paper | Tweet

6. Progressive Disclosure

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

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

Paper | Tweet

7. Structured Output Collapses Diversity

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

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

Paper | Tweet

8. Bad Memory in Agents

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

Paper | Tweet

9. Copying and 2D-RoPE

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

Paper | Tweet

10. RoboTTT

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

Paper | Tweet

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

Sat, 25 Jul 2026 17:20:58 GMT

In today’s issue:

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

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

🥇Top AI Papers of the Week

Sun, 19 Jul 2026 16:32:34 GMT

1. Self-Improving Agents Survey

Self-improving agents are moving from research demos into deployed systems, and this survey gives the trend a clean formalism. It frames a modern agent as a foundation model coupled with an operational scaffold of prompts, memory, tools, and control logic, then treats self-improvement as a self-induced update that commits changes to either the weights or the scaffold.

Two update targets: Improvement splits into foundation-model updates to the weights and scaffolding updates to prompts, tools, memory, and control code, giving a shared vocabulary for work that usually looks unrelated.
Signals that drive change: The survey organizes methods by where the learning signal comes from, spanning intrinsic generative demonstrations, intrinsic evaluative feedback, and extrinsic exploratory experience in real or simulated environments.
Full-scaffolding frontier: The most open-ended methods rewrite the agent itself through self-referential code updates, generate-test-patch loops, and open-ended search over agent designs, pushing toward controllable evolution with little human input.
Why it matters: As teams wire agents to improve from their own experience, a single map of update targets, signals, and applications across software, web, gaming, science, and robotics turns a scattered literature into something builders can actually navigate.

Paper | Tweet

From DAIR Academy

Want a guided version of a real weekend project? Our new hands-on lab, Docs for Agents with OpenWiki, has you run OpenWiki, LangChain’s documentation agent, against a real codebase. You generate an agent-ready wiki, steer what it writes, and keep the docs in sync as the code changes, across seven labs with automated checkpoint grading.

Take the Lab

2. Metacognition in LLMs

Confidence calibration, self-verification, knowing when to stop, and knowing what you do not know have mostly been studied in isolation. This survey from Yale and UC Irvine argues they are facets of one capability, metacognition, and organizes the field around a monitor and control loop wrapped around the language model.

Monitor and control framing: The model self-assesses before and after acting, then self-regulates by deciding whether to answer, retry, or defer, turning scattered behaviors into a single monitor-then-control cycle.
How it is measured: The survey catalogs psychology-based methods from signal detection theory, confidence-based metrics like calibration, AUROC, and ECE, activation-level neurofeedback, and interpretability probes such as concept injection.
How it is instilled and used: It reviews frameworks, architectures, prompting, and training that give LLMs, reasoning models, and agents metacognition, then shows gains in hallucination reduction, knowledge-boundary detection, and resistance to persuasion.
Why it matters: Metacognition underpins reliability, so a unified account of how to elicit, measure, and improve it gives builders a coherent target rather than a pile of one-off confidence tricks.

Paper | Tweet

3. When Is Routing Meaningful

LLM routers and mixture-of-agents systems get judged on accuracy and cost, both of which can look great while the router is doing nothing. This DeepMind-affiliated work argues that whether routing means anything depends on two properties that are orthogonal to accuracy.

Two conditions for real routing: The society of models must be behaviorally differentiated, since routing is vacuous when every actor responds the same way, and assignments must stay stable when a query is rewritten.
A diversity measure that sees structure: The authors use Hierarchic Social Entropy to score how genuinely different a pool of models is, showing purpose-built specialist societies are far more diverse than large real-world model pools of similar size.
Accuracy hides fragility: Learned KNN routers gain accuracy on specialist societies yet collapse under paraphrase perturbations, while a prompted router keeps both accuracy and robustness, so clean-query accuracy alone can mask a meaningless router.
Why it matters: These two checks catch routers that look good and do nothing, and they show that a small, carefully curated society can recover most of the diversity of a much larger pool.

Paper | Tweet

4. Harness Evolution Rethought

Automatic harness evolution is what many teams now use to squeeze more out of agents, but the reported gains might not be coming from the harness at all. This paper argues that harness evolution is itself a search procedure and must be compared against simple search baselines under matched budgets.

A fairer comparison: Because harness evolution repeatedly evaluates and revises candidates using task feedback, it should be benchmarked against task-level search under the same feedback and inference budgets, not against a single static harness.
The gains do not hold up: On Terminal-Bench 2.1 with GPT-5.4 and Claude Opus 4.6, evolved harnesses fall to 67.4, below the 68.2 baseline, while plain parallel sampling reaches 72.3 and harness scaling reaches 71.8.
Weak generalization: Beyond underperforming simple test-time scaling, the evolved harnesses transfer poorly, undercutting the assumption that a searched configuration captures something durable.
Why it matters: The result is a caution for anyone banking on self-evolving harnesses, and a call for evaluation protocols that separate genuine harness benefit from the effect of simply spending more compute on search.

Paper | Tweet

5. Tracing Agentic Failure

Finding which step in a failed agent run actually caused the failure usually means either labeling failure data or running expensive per-step prompting. This Microsoft and UW-Madison work skips both by learning what success looks like and flagging deviations from it.

Train on success, judge failure: OAT uses one-class learning with neural controlled differential equations to model the latent dynamics of successful trajectories, then scores each step of a failed run by how far it strays from that learned flow.
Cheap and label-free: With only 100 successful trajectories and no failure labels, it turns failure attribution into anomaly detection, avoiding the annotation and prompting costs that make current methods impractical at scale.
Strong, fast results: It delivers a 200 to 5000 times speedup over prompting-based attribution while improving F1 by 20% in-domain and 7% out-of-distribution.
Why it matters: Production agents fail in long, probabilistic, tool-mediated runs where the decisive misstep is hard to localize, and a cheap detector that only needs success data makes routine debugging feasible.

Paper | Tweet

6. Failure as a Process

When a coding agent fails a task, the final pass or fail label hides when the run actually went wrong. This large-scale study treats failure as a timeline and annotates over 63,000 execution steps to see how coding-agent runs break down.

Failure has three timestamps: Each trajectory is marked with the decisive error, the point where the error becomes irreversible, and the first observable failure, exposing a fix window and an observability lag that pass or fail labels erase.
Built on real trajectories: The team collected 3,843 runs from seven frontier models across three scaffolds on Terminal-Bench, filtered to 1,794 valid trajectories, and annotated them with high inter-rater agreement.
Mostly epistemic, mostly early: About 57.9% of failures come from misusing available information rather than a capability gap, with false premises the single largest trigger at 30.7%, and errors typically start early and stay hidden until recovery is impossible.
Why it matters: Naming the onset, lock-in, and observation points gives teams a vocabulary to intervene before an agent run is unrecoverable, instead of only noticing at the end.

Paper | Tweet

7. LingBot-World 2.0

Most world models fall apart after a few seconds, smearing textures and warping geometry as errors compound frame to frame. LingBot-World 2.0 from Robbyant holds 720p at 60 fps for a full hour of interaction and ships fully open.

Causal backbone beats drift: A causal generation stack trained from the start to limit error accumulation replaces the usual bidirectional design, keeping scenes coherent well past the point where prior causal models collapse.
Durable teacher, real-time student: The high-capacity base model is distilled into a few-step student that renders in real time, so you get both long-horizon stability and responsive interaction from one system.
Act inside the world: Rather than only moving a camera, you can fight, draw a bow, cast spells, and type in events like weather changes, while an agentic harness of a scene-reading brain, a pilot, and a director keeps generating context-aware content.
Why it matters: Pairing hour-scale, real-time, high-fidelity generation with an open release, including a 14B model and a lighter single-GPU variant, gives researchers a serious interactive world model to build on rather than a closed demo.

Paper | Tweet

8. Filtered Sabotage Monitoring

Chain-of-thought monitoring is treated as a reliable safety layer, but this study shows monitors often detect sabotage better with less access, not more. Giving a monitor the full agent reasoning trace can bury the signal, and the authors introduce extract-and-evaluate monitoring, where one monitor isolates the relevant excerpts and another scores them, lifting sabotage detection by 16.8 points on BigCodeBench-Sabotage with a GPT-4.1-mini monitor. Agents unaware they are watched are far easier to catch, and monitors reading long traces gain the most from filtering.

Paper | Tweet

9. GFlowRL

Reward-maximizing RL tends to collapse large reasoning models onto a single dominant mode, and GFlowNet-style training is appealing because it matches reward distributions and keeps diverse reasoning paths. GFlowRL scales this to modern post-training by replacing the hard-to-learn partition function with an in-batch Monte Carlo estimate computed from the rollout group the pipeline already produces. It is the first GFlowNet-style RL algorithm to train stably across both dense and sparse architectures, reaching a 2048 Codeforces rating at 14B and outperforming prior methods on math, code, and adversarial red-teaming benchmarks like AdvBench and HarmBench.

Paper | Tweet

10. LingBot-VLA 2.0

LingBot-VLA 2.0 is an open-source generalist embodied model from Robbyant, trained across 20 robot configurations from single-arm rigs to humanoids like Unitree G1 and Fourier GR-2. It packs 60,000 hours of curated data, 50,000 hours of real-robot trajectories plus 10,000 hours of egocentric human video, into one policy that also predicts future depth and semantic features before it acts. On 9 GM-100 tabletop tasks it beats π0.5 and GR00T N1.7 across two robot platforms and stays ahead on long-horizon mobile tasks, running at about 130 ms on a single RTX 4090D with open-sourced post-training code.

Paper | Tweet

🤖 AI Agents Weekly: Kimi K3, Thinking Machines Inkling, Agentic Misalignment, Perplexity SPACE, Sunday ACT-2, GPT-Red, and More

elvis — Sat, 18 Jul 2026 15:00:48 GMT

In today's issue:

Moonshot open-sources Kimi K3
Thinking Machines ships Inkling weights
Anthropic finds new agent misalignment
Perplexity opens SPACE agent runtime
Sunday Robotics unveils ACT-2
OpenAI launches GPT-Red red teamer
Meituan open-sources LongCat-2.0
schema harness saturates ARC-AGI-3

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

🥇Top AI Papers of the Week

Sun, 12 Jul 2026 16:12:55 GMT

1. Verification as a Scaling Axis

Verification is emerging as a distinct scaling axis alongside pre-training and test-time compute, and this Stanford, NVIDIA, and UC Berkeley collaboration builds a training-free verifier that reads a continuous, calibrated score straight off the scoring-token logits instead of trusting a discrete pass or fail grade.

Scores from logits, not grades: Rather than asking a judge model for a discrete verdict, the method reads a continuous calibrated score off the scoring-token logits, giving a smoother and more informative signal with no fine-tuning.
Three tuning knobs: Accuracy improves through score granularity for cleaner separation, repeated evaluation to cut variance, and criteria decomposition to reduce complexity, all without touching model weights.
Broad, strong numbers: It reaches 86.5% on Terminal-Bench V2, 78.2% on SWE-Bench Verified, 87.4% on RoboRewardBench, and 73.3% on MedAgentBench, spanning coding, robotics, and medical agents.
Why it matters: The same continuous score doubles as a dense reward for SAC and GRPO and as a task-progress signal shipped in a Claude Code extension, so one verifier serves evaluation, training, and live agent monitoring at once.

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. Always-On Agents

Always-on agents are systems whose future behavior depends on durable state built up across earlier interactions, and this 130-plus page survey argues that state is far more than memory. It spans task ledgers, permissions, credentials, commitments, provenance, triggers, and effects the agent has already committed to the outside world.

State as first-class, not just memory: The survey reframes agent state to include authority, obligations, and externally committed effects, the things that make a long-lived agent consequential rather than merely conversational.
Six axes per state item: Each piece of state is scored on authority, scope, mutability, provenance, recoverability, and actionability, giving builders a vocabulary for reasoning about what a stored fact can actually do.
A full state lifecycle: It traces state from write and retrieve through forget, audit, and rollback, surfacing the operational questions that production always-on systems must answer.
Why it matters: As agents move from single sessions to continuous operation, treating durable state as a governed, auditable resource is what separates a safe long-running system from one that quietly accumulates risk.

Paper | Tweet

3. HOLA

Linear-attention and state-space models compress an entire prefix into a fixed-size state, buying constant memory but overwriting earlier facts when many key-value associations compete. HOLA gives linear attention a hippocampal complement, pairing a compressive recurrent state with a small exact memory to recover long-range recall.

Two memories, different jobs: HOLA keeps the usual delta-rule state as compressive memory and adds a bounded exact KV cache, forming a semiparametric test-time memory where each store handles what it is best at.
Selective, learning-free writes: The cache writes without a learned eviction module, keeping only tokens whose prediction residual was actually committed to the state, so it stores exactly the associations that should not be forced through compression.
Strong recall at small scale: At 340M parameters on 15B SlimPajama tokens, it lowers Wikitext perplexity from 27.32 to 22.92, below a full-attention Transformer++ at 26.88, and stays robust on RULER needle recall out to 32k tokens, 16 times its training length.
Why it matters: It shows you can keep linear attention’s efficiency and still recover the exact recall that pure compression destroys, a practical path for long-context models that cannot afford full attention.

Paper | Tweet

4. Puzzle-75B

Bigger mixture-of-experts models keep winning on quality, but serving them at interactive latency is still hard. NVIDIA compresses the hybrid MoE Nemotron-3-Super into Puzzle-75B-A9B and roughly doubles interactive server throughput while holding quality.

Joint structural search: Heterogeneous MoE pruning, active-parameter budget, and Mamba pruning are optimized together rather than one at a time, wrapped in an iterative pipeline with distillation, RL, quantization, and a Multi-Token Prediction head.
Large throughput gains: On a single 8xB200 node it hits about 2x the parent’s server throughput at matched user-throughput, a direct win for anyone serving these models under latency constraints.
Concurrency at long context: At 1M-token context on a single H100, concurrency climbs from 1 request to 8, expanding what long-context workloads a single accelerator can host.
Why it matters: Accuracy holds across reasoning, coding, long-context, and agentic benchmarks, so cheaper serving with agentic capability intact changes what teams can afford to run in production.

Paper | Tweet

5. The Harness Effect

As orchestration harnesses mediate every model call, this study asks how much the harness alone moves cost and performance. It ran 22 evaluation tasks across six foundation models, then changed only the orchestration layer while holding the models constant.

Harness-only, models fixed: By varying just the orchestration layer over models like Claude Sonnet 4.6, Gemini 3.1, Qwen 3.6, and GLM 5.1, the study isolates the harness as the variable and measures its independent effect.
Big, consistent savings: Holding models constant, the harness cuts blended cost per task 41%, tokens per task 38%, and median wall-clock 44%, with completion quality at parity.
Two clean regularities: Efficiency is model-invariant, every model gets 33 to 61% cheaper, while quality gain correlates almost perfectly with baseline model strength (r=0.99), an effect the authors call harness leverage.
Why it matters: On this workload the orchestration layer moved cost per task more than the entire spread of the model menu did, making the harness the one component whose efficiency multiplies across every model a team runs.

Paper | Tweet

6. ReContext

Models now support 128K context windows yet still fail to use evidence already sitting in the prompt. ReContext is a training-free inference harness for long-context reasoning that uses model-internal relevance signals to build a query-conditioned evidence pool, then replays it right before final generation while preserving the full original context.

Memory framing of context: It treats the context as a memory store, the question as a retrieval cue, attention as cue-trace association, and replay as trace reactivation, a clean cognitive analogy that drives the design.
No training, no pruning: There is no fine-tuning, no external memory, and no pruning of the original context, so the method drops into existing models without changing weights or losing information.
Consistent gains across backbones: Across eight 128K long-context datasets it improves evidence utilization on Qwen3-4B, Qwen3-8B, and Llama3-8B, taking the best average rank on all three, with public code.
Why it matters: It targets the real long-context failure, using evidence that is already present, and fixes it at inference time, a cheap and general lever for reasoning over long prompts.

Paper | Tweet

7. Agent Limitations Taxonomy

Benchmark scores keep climbing, yet the same agent failures resurface across otherwise unrelated evaluations, hidden behind the leaderboard. This University of Oxford work synthesizes 27 benchmark, taxonomy, and audit papers spanning 19 benchmarks into the first cross-cutting taxonomy of LLM-agent limitations.

Six failure clusters: The taxonomy names tool invocation and parameter errors, planning and constraint-satisfaction failures, long-horizon degradation from context accumulation, multi-agent coordination breakdowns, safety failures under adversarial or underspecified conditions, and measurement validity problems.
Failures compound nonlinearly: Reliability drops faster than task length grows, so strong sub-task scores do not add up to end-to-end success on longer tasks.
Scaffolding is not a fix: Adding scaffolding does not reliably improve reliability, undercutting the assumption that more orchestration automatically buys robustness.
Why it matters: By giving shared names to failures that leaderboards obscure, the taxonomy helps teams diagnose why agents break in production instead of trusting benchmark gains that do not transfer.

Paper | Tweet

8. BlockSearch

BlockSearch runs the first systematic study of in-context retrieval at the scales real retrievers actually face, million-token corpora and length generalization far beyond training size. It introduces a 0.6B language-model retriever whose architectural and training changes improve over prior LM baselines and length-generalize up to 10 times beyond their training length, pointing toward retrievers that stay reliable as context windows keep growing.

Paper | Tweet

9. RLVR Meets Human Likeness

RL with verifiable rewards only optimizes what you can objectively score, so style, structure, and diversity quietly collapse and reward hacking creeps in. This MIT work adds an adversarial discriminator trained on human demonstrations as a learned proxy for the human output distribution, and the generator maximizes both task accuracy and that human-likeness signal. Across bug fixing, story generation, and a reward-hacking benchmark, it preserves RLVR’s accuracy gains while restoring the fuzzy properties it usually destroys, with misbehavior nearly disappearing.

Paper | Tweet

10. Replicating ML Papers with Agents

This work tests whether a coding agent can replicate a scientific ML paper from its materials alone, using a skill that turns each paper claim into a target with recorded evidence and gating completion on workspace evidence rather than the agent’s final message. Across twelve runs over four papers, all twelve workspaces pass the completion gate and all 158 recorded targets are matched with report coverage. Yet repeated runs still differ in how papers are split into targets and in numerical fidelity, so completion becomes reproducible even when the path is not.

Paper | Tweet

🤖 AI Agents Weekly: GPT-5.6 Family, Meta Muse Spark 1.1, Grok 4.5, SWE-1.7, Robostral Navigate, The Harness Effect, and More

Sat, 11 Jul 2026 16:33:08 GMT

In today’s issue:

OpenAI ships the GPT-5.6 family
Meta releases Muse Spark 1.1
OpenAI launches ChatGPT Work agent
xAI releases Grok 4.5 for coding
Cognition ships SWE-1.7 at 1000 tok/s
Mistral drops Robostral Navigate
Harness design sets agent economics
OpenAI launches GPT-Live voice
Google open-sources Gemma 4
Tencent open-sources 295B Hy3
Google ships Cloud Run sandboxes
Nous puts Hermes Agent in the cloud
Microsoft releases Flint for agents
Ternlight runs embeddings in-browser
GPT-5.6 proves 50-year math conjecture
Databricks benchmarks coding agents
OpenAI audits SWE-Bench Pro
FrontierFinance benchmarks agent analysts
Paper turns memory into navigation
GitLost tricks GitHub’s AI agent
Anthropic finds a global workspace
Sakana replays Picbreeder with VLMs

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

🥇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

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.

AI Newsletter

🥇Top AI Papers of the Week

1. Declarative Attention

2. Harness-of-Harness

3. WikiSkill

4. SKILL.state

Message from the Editor

5. CORAL

6. E-Commerce Bench

7. AI Research Preference Models

8. Trace as State

9. Selective Forgetting

10. Runtime-Independent Persistent Agents

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

Top Stories

OpenAI Ships GPT-6 Astra

🥇Top AI Papers of the Week

1. Judges as a Lifecycle

2. Skill Lift

3. Context Management as Code

4. JIT-Agent

Message from the Editor

5. Prime Agent

6. What Compaction Destroys

7. Co-Scientist in Real Labs

8. Recuris

9. Meta^n

10. EvoMal

🤖 AI Agents Weekly: GLM-5.3-Flash, Hy4 Preview, Qwen3.8-Flash, Claude's Built-In Browser, Terminal-Bench-Science, Jalapeño, Skild S1, and More

Top Stories

GLM-5.3-Flash Ships Under MIT

🥇Top AI Papers of the Week

1. Agent Lightning v1.0

2. The Skill Trigger Bottleneck

3. Harness-Level Forgetting

4. The Control-Plane Tax

Message from the Editor

5. Demystifying Agent Skills

6. Strategy Lock-In

7. SocialRL

8. ClawGym II

9. Inside an Agent Team

10. Fragile Self-Improvement

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

Top Stories

NVIDIA AVO Solves ARC-AGI-3

TrueFoundry Open-Sources TrueForge

🥇Top AI Papers of the Week

1. Skaling

2. Stealing Reasoning Traces

3. Mind Viruses

4. Catastrophic Remembering

Message from the Editor

5. Programmatic Tool Calling

6. Distilled Reasoning Skills

7. Harness-IF

8. Lost in Compaction

9. Cracks in the Foundation

10. CEDAR

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

Top Stories

DeepSeek Open-Sources Its Agent Harness

DeepSeek Launches V4-Pro

🥇Top AI Papers of the Week

1. Model or Harness

Message from the Editor

2. Zero-Mem

3. Sample More Reflect Less

4. Harness-R1

5. DataSpace

6. Prompt-Induced Waste

7. Rehearse

8. ContinualSkillBench

9. MerchantBench

10. TokTier

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

Top Stories

Agent Plugins Standard Launches

Alibaba Launches Qwen3.8-Max

🥇Top AI Papers of the Week