# AI Papers of the Week — 2026

[← Back to main index](../README.md)

This page collects every weekly issue of **AI Papers of the Week** from 2026. For other years, see the [main index](../README.md).

---

## Top AI Papers of the Week (August 17 - August 23) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **Agent Lightning v1.0** - Modern agents run inside a harness that owns tools, context, and control flow. When you want to train one, that ownership becomes the problem: the harness runs the environment loop and the trainer only ever sees LLM request and response pairs. This work from Microsoft treats that boundary as the integration point instead of an obstacle. <br>● The harness stays opaque: An endpoint proxy sits at the model boundary and connects any harness to RL in roughly 3,500 lines, so agents built on mini-SWE-agent, OpenHands, or OpenClaw train without being rewritten for the trainer.  <br>● The hard part is everything after the proxy: The paper works through what actually breaks in that setup, retokenization, sample merging, advantage calculation, loss normalization, and backend scheduling. That list is the real contribution, because each item silently corrupts gradients when a harness sits between the policy and the reward.  <br>● 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%.  <br>● Why it matters: This is the clearest expression yet of the theme running through this week's papers, that the harness is a first-class object in the training stack rather than deployment plumbing. If your agent already works, you can now train the model against the exact system it runs in. | [Paper](https://arxiv.org/abs/2608.17528), [Tweet](https://x.com/omarsar0/status/2090078336697733531) |
| 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 argues the scarcity is an artifact of how skills get installed, not a real limit. <br>● 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 and prices each tier by what it actually costs.  <br>● 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.  <br>● Vendoring gives you ownership: Copying a skill into your Git tree at the same path means your team owns and adapts it, with zero token cost until it is named.  <br>● 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 is the useful part even if you never adopt the protocol: decide per skill whether it needs to fire unasked, and most of yours do not. | [Paper](https://arxiv.org/abs/2608.12610), [Tweet](https://x.com/omarsar0/status/2089411994499903566) |
| 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. <br>● 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, which is what was missing.  <br>● 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.  <br>● It generalizes across modality: Relative gains exceed 10% across textual reasoning, multimodal perception, and open-world interaction, so this is not tuned to one benchmark family.  <br>● 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 the cheap part to add, and the historical retention check is the one most self-editing setups skip. | [Paper](https://arxiv.org/abs/2608.19013), [Tweet](https://x.com/omarsar0/status/2090533587066249514) |
| 4) **The Control-Plane Tax** - Serving systems for agentic applications are still built on 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. <br>● 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.  <br>● 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 is what makes naive per-session provisioning so expensive.  <br>● The tax is auxiliary calls: Helper LLM calls and tool schema overhead form a control-plane tax that crowds out productive compute, which is invisible if you only profile the main generation path.  <br>● 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](https://arxiv.org/abs/2608.15127), [Tweet](https://x.com/dair_ai/status/2090117595907383672) |
| 5) **Demystifying Agent Skills** - Skills are usually assumed to inject knowledge the model lacks. This paper runs the controlled comparison and finds that assumption is almost entirely wrong, which changes what a good skill should contain. <br>● 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 stabilize execution rather than supply information.  <br>● 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.  <br>● 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.  <br>● 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, keep the active set small, and stop treating them as a place to dump reference material. | [Paper](https://arxiv.org/abs/2608.14036), [Tweet](https://x.com/omarsar0/status/2089376463330128151) |
| 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. <br>● 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. There is no mechanism for stepping back out.  <br>● Better scaffolding lifts execution, not strategy: 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.  <br>● 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.  <br>● Why it matters: What agents lack here is a way to reconsider strategy while execution is still running. That is a different problem from reasoning quality or tool use, and none of the three escalating fixes tried here touch it, which sets a clear target for the next round of work. | [Paper](https://arxiv.org/abs/2608.19072), [Tweet](https://x.com/omarsar0/status/2090466402809561334) |
| 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. <br>● 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, with private information and asynchronous multi-agent interaction built into the environment.  <br>● The behavioral shift is stark: After training, 78% of buyer openings anchor below target, against 3% untrained. That is a learned strategic prior rather than a prompting trick.  <br>● 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.  <br>● Why it matters: Assistant alignment and delegate alignment are not the same objective, and this is the first paper to make that gap measurable. As agents start transacting on behalf of users, the friendly-by-default posture stops being a safety feature and starts being a leak. | [Paper](https://arxiv.org/abs/2608.13787), [Tweet](https://x.com/dair_ai/status/2089379232648778111) |
| 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: one model optimized jointly by heterogeneous harnesses, which points at policies that generalize across execution systems instead of overfitting to a single one. | [Paper](https://arxiv.org/abs/2608.16798), [Tweet](https://x.com/omarsar0/status/2089828440572846461) |
| 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](https://arxiv.org/abs/2608.16801), [Tweet](https://x.com/omarsar0/status/2089741366331146694) |
| 10) **The Fragility of Self-Improving Agents** - 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 rather than averaging it out. 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](https://arxiv.org/abs/2608.18066), [Tweet](https://x.com/dair_ai/status/2090559561128407336) |

---


## Top AI Papers of the Week (August 10 - August 16) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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 part worth reading closely. | [Paper](https://arxiv.org/abs/2608.07222), [Tweet](https://x.com/omarsar0/status/2086845790983716917) |
| 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. <br>● 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.  <br>● 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.  <br>● Four attack vectors, not one: 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.  <br>● Why it matters: Teams publish session logs assuming the encrypted blobs are opaque, and they are not. The authors disclosed responsibly and propose cryptographic and system-level mitigations, but the immediate action is auditing what your published traces actually contain. | [Paper](https://arxiv.org/abs/2608.09867), [Tweet](https://x.com/omarsar0/status/2087187835530948776) |
| 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. <br>● Evolved, not hand-written: The payloads are constructed with a simple evolutionary algorithm rather than authored, so the study measures what actually spreads instead of what a researcher guessed would spread.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2608.10218), [Tweet](https://x.com/omarsar0/status/2087574841893474556) |
| 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. <br>● 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.  <br>● 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.  <br>● Rewrites do not fix it: A wholesale rewrite resets a prompt's size but not its growth rate. The ratchet survives the bulldoze.  <br>● 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](https://arxiv.org/abs/2608.11095), [Tweet](https://x.com/omarsar0/status/2087605040240582991) |
| 5) **The Bitter Lesson of 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● Why it matters: The advantage tracks model capability across release generations, so it grows as coding ability grows. That makes this less a tuning trick than a directional bet about which interface to build your harness around. | [Paper](https://arxiv.org/abs/2608.06370), [Tweet](https://x.com/dair_ai/status/2086846794840019178) |
| 6) **Reason Wide, Not Deep** - 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 means the cost is recurring by accident rather than by necessity. <br>● Pay once, not per episode: 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.  <br>● 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.  <br>● Reasoning traces are not required: Skills distilled from non-reasoning trajectories alone stay competitive with skills distilled from paired corpora, with domain-dependent differences in either direction.  <br>● 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](https://arxiv.org/abs/2608.07885), [Tweet](https://x.com/dair_ai/status/2087264294782279808) |
| 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. <br>● Rules are the unit, not tasks: 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.  <br>● 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%.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2608.11727), [Tweet](https://x.com/omarsar0/status/2087962456572498142) |
| 8) **Lost in Compaction** - Context compaction is now standard in long-running agent systems, and it silently drops the instructions users most expect to persist. This work names that class, Session Constraints, instructions like "do not delete any emails until I confirm" meant to bind behavior for the rest of a session, and introduces COMPINT to evaluate compactors across multi-turn chat, agentic trajectory, and long-horizon research. Current compactors retain only 17% of injected constraints on average, and most leave the task worse off than running it without compaction at all. Retention swings with the compactor, the prompt, the context length, the phrasing, and where the constraint was injected, which is what makes the loss structural rather than a quirk of one setup. The fix is small and does not touch the compactor or the model: an SC-aware extractor running alongside as a plug-and-play module recovers over 90% retention in all three scenarios. | [Paper](https://arxiv.org/abs/2608.11242), [Tweet](https://x.com/dair_ai/status/2087930434323959894) |
| 9) **Cracks in the Foundation** - You might assume architectural variations within the dense transformer paradigm barely move accuracy, and in the short-context setting you would be right. This work shows four minor decisions, normalization, GQA, pretraining context length, and sliding window attention, each made by at least one of the Olmo, Llama, and Qwen dense families, have a compoundingly negative effect on long-context extensibility. Any one alone is minor, but combining three or more drops downstream long-context performance by up to 47%, and none of it is detectable from short-context loss or validation sets, which is precisely how these choices survive into shipped models. Applying context extension early in pretraining exposes the problem cheaply. After over 170,000 GPU hours the authors release OlmPool, 26 comparable 7B models with checkpoints before and after extension, including several architectures that beat the Llama 3 architecture on long-context extensibility. | [Paper](https://arxiv.org/abs/2608.10296), [Tweet](https://x.com/dair_ai/status/2087600513441546589) |
| 10) **CEDAR** - Complex systems research models feedback-driven phenomena from population dynamics to economic policy, and its central open problem is that nobody can predict how feedback structure gives rise to emergent behavior, which makes goal-directed design very hard. CEDAR, from Sakana AI, attacks that with LLM agents running Monte Carlo Tree Search over the space of feedback structures rather than tuning parameters on a fixed one. Systems are represented as a restricted runnable subset of Python with domain-specific primitives so the models can edit dynamics directly, an LLM Judge scores emergent behavior against the stated goal as a fitness function, and an LLM Editor proposes variants as a variation operator. The formalization is an MCTS variant with an LLM-parameterized transition kernel and value function, which preserves solution diversity while searching, and the LLM-based interpretability makes it possible to read back how a structural change produced the behavior. | [Paper](https://arxiv.org/abs/2608.06871), [Tweet](https://x.com/dair_ai/status/2086950751314870703) |

---


## Top AI Papers of the Week (August 3 - August 9) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.28802), [Tweet](https://x.com/omarsar0/status/2084367708439949343) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.29377), [Tweet](https://x.com/dair_ai/status/2084370729332797724) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.28576), [Tweet](https://x.com/omarsar0/status/2084761324786172347) |
| 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. <br>● 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.  <br>● 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.  <br>● 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%.  <br>● 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](https://arxiv.org/abs/2608.02276), [Tweet](https://x.com/dair_ai/status/2084706693880135848) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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 competition. | [Paper](https://arxiv.org/abs/2608.03451), [Tweet](https://x.com/omarsar0/status/2085082167579902233) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2608.01347), [Tweet](https://x.com/omarsar0/status/2084714744880173451) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.27687), [Tweet](https://x.com/dair_ai/status/2084746281189270015) |
| 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](https://arxiv.org/abs/2608.03874), [Tweet](https://x.com/dair_ai/status/2085084179201704004) |
| 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](https://arxiv.org/abs/2607.28956), [Tweet](https://x.com/dair_ai/status/2084413007514550720) |
| 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](https://arxiv.org/abs/2607.29678), [Tweet](https://x.com/omarsar0/status/2084414040760275278) |

---

## Top AI Papers of the Week (July 27 - August 2) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.20709), [Tweet](https://x.com/omarsar0/status/2082602113558077599) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.04763), [Tweet](https://x.com/dair_ai/status/2081560214554419700) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.22925), [Tweet](https://x.com/dair_ai/status/2082111593270383082) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.21653), [Tweet](https://x.com/dair_ai/status/2081770344952803628) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.20466), [Tweet](https://x.com/omarsar0/status/2081530022947705201) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.23809), [Tweet](https://x.com/omarsar0/status/2082105300392542246) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.26637), [Tweet](https://x.com/dair_ai/status/2082883931582713893) |
| 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](https://arxiv.org/abs/2607.20548), [Tweet](https://x.com/omarsar0/status/2081471875885203791) |
| 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](https://arxiv.org/abs/2607.21627), [Tweet](https://x.com/omarsar0/status/2081834515849515325) |
| 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](https://arxiv.org/abs/2607.25816), [Tweet](https://x.com/dair_ai/status/2082677582378811762) |

---

## Top AI Papers of the Week (July 20 - July 26) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.13285), [Tweet](https://x.com/omarsar0/status/2080296884187652381) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.16621), [Tweet](https://x.com/dair_ai/status/2079706493495234693) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.20064), [Tweet](https://x.com/dair_ai/status/2080345957204697261) |
| 4) **Global Workspace in LLMs** - This Anthropic interpretability work gives a mechanistic account of when a model's verbalized reasoning is load-bearing and when it is not. It identifies a small, privileged set of internal representations that behaves like the global workspace some neuroscientists tie to conscious access. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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 scope the claim to access, not phenomenal experience. | [Paper](https://arxiv.org/abs/2607.15495), [Tweet](https://x.com/omarsar0/status/2079235153210355754) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.19322), [Tweet](https://x.com/dair_ai/status/2079928205570637840) |
| 6) **Progressive Disclosure, Measured** - 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 was anecdotal until now. <br>● 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.  <br>● The gain is harness-dependent: On a single book, progressive disclosure helps a lot when the agent navigates the raw document poorly, but the benefit falls to near zero when a strong harness already divides and retrieves the text on its own.  <br>● Not a universal win: Because the pattern's value hinges on the surrounding harness rather than the skill format alone, treating progressive disclosure as an automatic upgrade can add complexity without buying accuracy.  <br>● 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](https://arxiv.org/abs/2607.17598), [Tweet](https://x.com/omarsar0/status/2079718100447166533) |
| 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. <br>● 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.  <br>● 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.  <br>● Not the decoder: Enforcing the schema at the decoder compresses no further than simply requesting it, so the collapse lives in the model's response to the structured register, not in constrained decoding.  <br>● 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](https://arxiv.org/abs/2607.18476), [Tweet](https://x.com/omarsar0/status/2079959935031591112) |
| 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 finding is uneven but sobering: it is hard to make an agent overwrite its own memory using untrusted external content, but 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](https://arxiv.org/abs/2607.14611), [Tweet](https://x.com/dair_ai/status/2078555662133665941) |
| 9) **Frontier Models Struggle to Copy** - 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](https://arxiv.org/abs/2607.16072), [Tweet](https://x.com/dair_ai/status/2079235898039042203) |
| 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](https://arxiv.org/abs/2607.15275), [Tweet](https://x.com/dair_ai/status/2078123816786813115) |

---

## Top AI Papers of the Week (July 12 - July 19) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.13104), [Tweet](https://x.com/omarsar0/status/2077792894459793714) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.11881), [Tweet](https://x.com/omarsar0/status/2077045732268560738) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.09197), [Tweet](https://x.com/dair_ai/status/2077048984812896677) |
| 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. <br>● 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.  <br>● 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.  <br>● Weak generalization: Beyond underperforming simple test-time scaling, the evolved harnesses transfer poorly, undercutting the assumption that a searched configuration captures something durable.  <br>● 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](https://arxiv.org/abs/2607.12227), [Tweet](https://x.com/dair_ai/status/2077427982390759803) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.12747), [Tweet](https://x.com/omarsar0/status/2077418921536410080) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.09510), [Tweet](https://x.com/dair_ai/status/2076699431207154069) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.07534), [Tweet](https://x.com/omarsar0/status/2077058222339338748) |
| 8) **Less Is More for Monitors** - 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](https://arxiv.org/abs/2601.21112), [Tweet](https://x.com/omarsar0/status/2076381586266931248) |
| 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](https://arxiv.org/abs/2607.13394), [Tweet](https://x.com/dair_ai/status/2077802951612256673) |
| 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](https://arxiv.org/abs/2607.06403), [Tweet](https://x.com/omarsar0/status/2077404813055185320) |

---

## Top AI Papers of the Week (July 5 - July 12) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.05391), [Tweet](https://x.com/omarsar0/status/2074556579580711050) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2606.30306), [Tweet](https://x.com/omarsar0/status/2073850909684293780) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.02303), [Tweet](https://x.com/omarsar0/status/2073068756293869685) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.04371), [Tweet](https://x.com/omarsar0/status/2074543978129793462) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.06906), [Tweet](https://x.com/dair_ai/status/2075241322655727682) |
| 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. <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.02509), [Tweet](https://x.com/dair_ai/status/2074178316819677238) |
| 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. <br>● 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.  <br>● 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.  <br>● Scaffolding is not a fix: Adding scaffolding does not reliably improve reliability, undercutting the assumption that more orchestration automatically buys robustness.  <br>● 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](https://arxiv.org/abs/2607.05775), [Tweet](https://x.com/dair_ai/status/2074874153245814864) |
| 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](https://arxiv.org/abs/2607.01538), [Tweet](https://x.com/dair_ai/status/2074117920133898707) |
| 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](https://arxiv.org/abs/2607.01181), [Tweet](https://x.com/dair_ai/status/2073119635214602638) |
| 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](https://arxiv.org/abs/2607.02134), [Tweet](https://x.com/dair_ai/status/2073065231790809214) |

---

## Top AI Papers of the Week (June 28 - July 5) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 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. --- --- <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2606.26294), [Tweet](https://x.com/omarsar0/status/2071285506630160761) |
| 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. --- <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2606.30317), [Tweet](https://x.com/omarsar0/status/2072076720367341933) |
| 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. --- <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2606.26300), [Tweet](https://x.com/omarsar0/status/2071763405049123258) |
| 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. --- <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2606.28277), [Tweet](https://x.com/dair_ai/status/2071688411229094397) |
| 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. --- <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2606.32025), [Tweet](https://x.com/omarsar0/status/2072430551446032847) |
| 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. --- <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2607.01224), [Tweet](https://x.com/omarsar0/status/2072716688483831885) |
| 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. --- <br>● 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.  <br>● 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.  <br>● 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.  <br>● 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](https://arxiv.org/abs/2606.32032), [Tweet](https://x.com/dair_ai/status/2072470330535473485) |
| 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](https://arxiv.org/abs/2607.00272), [Tweet](https://x.com/dair_ai/status/2072719460721733762) |
| 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](https://arxiv.org/abs/2606.28279), [Tweet](https://x.com/dair_ai/status/2071748305416253676) |
| 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](https://arxiv.org/abs/2606.26797), [Tweet](https://x.com/dair_ai/status/2071368061580706126) |

---

## Top AI Papers of the Week (June 21 - June 28) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **Sakana Fugu** - Frontier LLMs keep advancing, and different providers are increasingly specializing in distinct domains, which raises a natural next objective: how do you combine those individual specializations into one collectively intelligent system? Sakana Fugu answers with a family of orchestrator models that are themselves language models trained to read a user query and dynamically devise the agentic scaffold needed to solve it. <br>● Orchestrator models, not a fixed pipeline: Fugu is trained to understand a query and build an adaptive agentic scaffold on the fly, harnessing and amplifying a team of LLM agents rather than routing to a single frozen workflow.  <br>● Performance beyond any single agent: Through these query-adaptive scaffolds, Fugu reaches state-of-the-art results against other publicly accessible models across SWE-Bench Pro, Terminal Bench, LiveCodeBench, GPQA-Diamond, Humanity's Last Exam, and CharXiv Reasoning.  <br>● Two models for two regimes: They release Fugu, which balances answer quality against latency for everyday use, and Fugu-Ultra, which prioritizes quality on the hardest problems.  <br>● Why it matters: The training paradigm combines large-scale fine-tuning, evolutionary algorithms, and reinforcement learning, plus the infrastructure to turn that into a production system, pointing to dynamic, query-adaptive scaffolds and collective intelligence as a path toward the next frontier of AI capabilities. | [Paper](https://arxiv.org/abs/2606.21228), [Tweet](https://x.com/SakanaAILabs/status/2070521997696929883) |
| 2) **Agent-Native Memory** - Memory for LLM agents has quietly grown from a retrieval add-on into a full data system, with persistent storage, retrieval, update, consolidation, and lifecycle governance running throughout an agent's execution. Yet most evaluations still score memory only through end-to-end task metrics like F1 and BLEU, treating the whole stack as a black box. This paper studies agent memory from a data management perspective and asks what we are actually missing when we measure it that way. <br>● A data management view of memory: The authors argue that operational cost, architectural trade-offs across memory modules, and robustness under dynamic knowledge updates are first-class concerns that task-success metrics hide entirely.  <br>● A four-module decomposition: They break memory into representation and storage, extraction, retrieval and routing, and maintenance, then evaluate 12 representative memory systems plus two baselines across five workloads spanning 11 datasets.  <br>● No single architecture wins: Effectiveness depends on how well the memory structure matches the workload bottleneck, and fine-grained ablations quantify each module's effect on representation fidelity, retrieval precision, update correctness, and long-horizon stability.  <br>● Why it matters: The study shows localized maintenance is more cost-efficient than global reorganization, and reframing memory as a system with measurable trade-offs is what gets us toward genuinely agent-native memory rather than another leaderboard number. | [Paper](https://arxiv.org/abs/2606.24775), [Tweet](https://x.com/dair_ai/status/2069846777977880769) |
| 3) **Autodata** - Building synthetic training data has mostly stayed a fixed pipeline that you hand-tune once and then freeze. Autodata rethinks that by casting an AI agent as a data scientist that builds high-quality training and evaluation data, then meta-optimizes that agent so it learns to create even stronger data over time. <br>● An agent as data scientist: Autodata is a general formulation in which an AI agent plays the role of a data scientist building both training and evaluation data, instantiated as a concrete, practical implementation the authors call Agentic Self-Instruct.  <br>● Meta-optimization compounds the gains: Beyond using the agent to generate data, they train (meta-optimize) the data scientist agent itself, and this self-improvement step delivers a larger performance uplift than base agentic data creation alone.  <br>● Consistent across domains: On computer science research tasks, legal reasoning, and reasoning with mathematical objects, Autodata beats classical synthetic dataset creation methods, showing the approach is not tied to a single problem type.  <br>● Why it matters: Agentic data creation turns increased inference compute into higher-quality training data, offering a path that could change how teams build datasets rather than freezing a pipeline and hoping it generalizes. | [Paper](https://arxiv.org/abs/2606.25996), [Tweet](https://x.com/omarsar0/status/2070235085732000228) |
| 4) **Critique of the Agent Model** - The word agent now covers everything from a for-loop with tool calls to speculative machine superintelligence, which makes it nearly useless as a technical term. This position paper from Eric Xing and collaborators tries to fix that by asking what an agent actually is and what agency consists of, drawing on Descartes and on science-fiction portrayals of autonomous beings to ground the discussion. <br>● Five dimensions of agency: The authors analyze agent architectures along goal, identity, decision-making, self-regulation, and learning, and argue that genuine agency requires these structures to be internalized in the system rather than assembled through external scaffolding.  <br>● Agentic versus agentive: They draw a sharp line between agentic systems, whose competence lives in engineered workflows, and agentive systems, whose capabilities including social interaction arise endogenously, marking the boundary between task-specific tools and open-world autonomy.  <br>● A concrete architecture: Building on the analysis, they propose the Goal-Identity-Configurator, combining hierarchical goal decomposition, identity evolution, simulative reasoning grounded in a separately trained world model, learned self-regulation, and self-directed learning from real and simulated experience.  <br>● Why it matters: Clear definitions are not academic hair-splitting here. They shape what we build and what we should reasonably fear, and the paper centers auditability, controllability, and safety for systems that hold more autonomy yet stay under human oversight. | [Paper](https://arxiv.org/abs/2606.23991), [Tweet](https://x.com/omarsar0/status/2069907174252527816) |
| 5) **Agent-as-a-Router** - Most users now have access to many LLMs that each excel in different domains, so routing each task to the right model matters for both quality and cost. Existing routers treat this as a static, one-off classification problem, and this paper shows that framing is exactly what holds them back. <br>● Information deficit is the bottleneck: Simply augmenting a vanilla LLM router with performance statistics at the task-dimension level yields a 15.3% relative gain, surpassing a heuristic router built on the same priors, which pinpoints missing information rather than model choice as the real limiter.  <br>● Routing as a closed loop: Agent-as-a-Router formalizes routing as a Context, Action, Feedback, Context loop that accumulates execution-grounded experience during deployment instead of deciding once and moving on.  <br>● A concrete system and benchmark: The framework is instantiated as ACRouter, built from an Orchestrator, a Verifier, and a Memory module, and the authors release CodeRouterBench, roughly 10K task instances scored across 8 frontier LLMs for regret-based comparison on streaming tasks.  <br>● Why it matters: ACRouter achieves the lowest cumulative regret on in-distribution tasks and generalizes to out-of-distribution agentic programming, showing that treating routing as an experience-gathering agent, not a classifier, is what closes the information gap. | [Paper](https://arxiv.org/abs/2606.22902), [Tweet](https://x.com/dair_ai/status/2069575488570630587) |
| 6) **Agent Communication Protocols** - As multi-agent systems try to move past the limits of standalone agents, communication becomes the load-bearing infrastructure, and the protocol landscape for it is a fragmented mess. This study builds a technical taxonomy to classify and compare LLM agent communication protocols and to make the interoperability problem legible. <br>● A five-dimensional taxonomy: Following an established iterative method, the authors classify protocols along counterparty, payload, interaction state, discovery mechanism, and schema flexibility, derived through five iterations over nine actively maintained open-source protocols with real adoption.  <br>● Recurring architectural patterns: Every sampled agent-to-agent protocol combines hybrid payloads with session-state persistence, most support multiple predefined schemas, and two negotiate schemas at runtime, signaling a clear trend toward schema flexibility.  <br>● Where the gaps are: Decentralized discovery remains rare, and the analysis suggests short-term convergence pressure toward protocols that unify agent-to-agent and agent-to-context communication for tools and data.  <br>● Why it matters: No single protocol is likely to maximize versatility, efficiency, and portability at once, so the field will probably evolve into a federated, layered protocol stack, and this taxonomy gives teams a way to choose protocols and surfaces open problems like privacy and policy enforcement. | [Paper](https://arxiv.org/abs/2606.19135), [Tweet](https://x.com/omarsar0/status/2069066883995758814) |
| 7) **A Pinch of Human Data** - Self-play reinforcement learning can train driving policies with no human data at all, swapping expensive human demonstrations for cheap large-scale simulation. The catch is that pure self-play tends to discover effective but alien driving conventions that real people cannot work with, and the usual fixes lean on brittle reward engineering and domain randomization. <br>● Human data as a regularizer: Instead of discarding demonstrations or imitating them wholesale, the method treats human data as a regularization objective layered on top of a minimal safe goal-reaching reward, keeping behavior compatible with people without hand-tuning conventions.  <br>● A little goes a long way: Just 30 minutes of human demonstrations, roughly 2500 times fewer than comparable imitation learning approaches, is enough to pull self-play policies into human-compatible behavior.  <br>● Cheap to train: The resulting policies coordinate with held-out human trajectories and finish training in 15 hours on a single consumer-grade GPU, which keeps the recipe accessible rather than a frontier-lab luxury.  <br>● Why it matters: Behavioral alignment with humans is the hard part of deploying autonomous policies in shared environments, and this work shows that a tiny, well-placed dose of human data can fix what massive reward engineering struggles to, pointing to a cleaner path for human-AI coordination. | [Paper](https://arxiv.org/abs/2606.19370), [Tweet](https://x.com/dair_ai/status/2068456364691935326) |
| 8) **Skill-MAS** - Automatic generation of multi-agent systems is stuck between inference-time methods that reuse frozen frontier models but never learn, and training-time methods that internalize experience through gradient updates but are capped by the weaker models small enough to fine-tune. Skill-MAS proposes a third path that treats high-level orchestration as an evolvable Meta-Skill, decoupling experience retention from weight updates so frontier models keep getting better at orchestration without any gradient steps. Across four complex benchmarks and four distinct LLMs it delivers strong, transferable gains at a favorable cost-performance trade-off. | [Paper](https://arxiv.org/abs/2606.18837), [Tweet](https://x.com/dair_ai/status/2068380866997588221) |
| 9) **Reliability without Validity** - LLM-as-a-Judge is the default way to evaluate language models, but validating those judges with exact-match agreement never corrects for chance and systematically overstates how good they are. In the largest audit to date, spanning 21 judges from nine providers across MT-Bench, JudgeBench, and RewardBench over 118 runs and roughly 541,000 judgments, the gap between raw agreement and chance-corrected Cohen's kappa runs 33 to 41 percentage points, rankings shift by up to 14 positions across benchmarks, and high test-retest reliability coexists with severe position bias. The authors distill their findings into a Minimum Viable Validation Protocol so teams can stress-test judges before trusting them. | [Paper](https://arxiv.org/abs/2606.19544), [Tweet](https://x.com/dair_ai/status/2069063719817265463) |
| 10) **NatureBench** - Can coding agents move past reproduction toward actual discovery on real scientific problems? NatureBench distills 90 cross-discipline tasks from peer-reviewed Nature-family papers and runs them in NatureGym, an automated pipeline that builds a standardized containerized environment per task to fix the environment-fragmentation problem. Under a strict web-search-disabled protocol, the strongest of ten frontier agent configurations beats published SOTA on only 17.8% of tasks, and analysis shows agents win mainly by translating problems into familiar supervised prediction rather than through genuine scientific invention. | [Paper](https://arxiv.org/abs/2606.24530), [Tweet]() |

---

## Top AI Papers of the Week (June 14 - June 21) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **SpatialClaw** - Spatial reasoning over 3D and 4D scenes is still where general vision-language models break down, because they emit a text answer directly rather than measuring anything. From NVIDIA, SpatialClaw is a training-free framework that rethinks the action interface and lets a VLM-backed agent reason through code instead. The agent writes one Python cell per step into a persistent Jupyter kernel preloaded with perception primitives and scientific libraries, then inspects intermediate results and revises its strategy across steps. <br>● Code as the action interface: Perception tools like SAM3 segmentation, Depth-Anything-3 reconstruction, and geometry utilities are exposed as plain Python callables, so the agent composes them programmatically rather than guessing spatial relationships from pixels.  <br>● A persistent, stateful kernel: Masks, depth maps, camera geometry, and trajectories are ordinary Python variables that the kernel preserves across turns, so any object produced at one step stays available for composition, inspection, and revision later.  <br>● Strong results without adaptation: Across 20 spatial reasoning benchmarks spanning static and dynamic tasks, SpatialClaw reaches 59.9% average accuracy, beating the prior spatial agent by 11.2 points, with consistent gains across six VLM backbones from two model families.  <br>● Why it matters: Because it is training-free and model-agnostic, SpatialClaw turns code execution into a general substrate for spatial reasoning that any capable VLM can plug into, instead of requiring bespoke spatial fine-tuning. | [Paper](https://arxiv.org/abs/2606.13673), [Tweet](https://x.com/NVIDIAAI/status/2066974091689476320) |
| 2) **Compositional Skill Routing** - Real tasks rarely map to a single skill. They usually need several skills composed together, yet most skill routing still treats the problem as picking one tool from a library. This work formalizes Compositional Skill Routing, where an agent must select and sequence multiple reusable skills from large libraries to satisfy a complex query, and introduces SkillWeaver, a decompose, retrieve, and compose pipeline built around it. <br>● A three-stage pipeline: SkillWeaver decomposes a query into sub-tasks with an LLM, matches each sub-task to a skill using a bi-encoder with FAISS indexing, and then performs dependency-aware planning to assemble an executable plan.  <br>● A realistic benchmark: The authors release CompSkillBench, a benchmark of 300 compositional queries over 2,209 real MCP server skills spanning 24 functional categories, so routing is tested against actual tool ecosystems rather than toy libraries.  <br>● Decomposition is the bottleneck: Task decomposition quality emerges as the primary limiting factor, and Iterative Skill-Aware Decomposition, which feeds retrieval information back into the decomposition step, lifts accuracy from 51.0% to 67.7%.  <br>● Why it matters: As agent skill libraries scale to thousands of entries, single-tool routing stops being enough, and treating routing as a compositional planning problem is what lets agents handle genuinely multi-step requests. | [Paper](https://arxiv.org/abs/2606.18051), [Tweet](https://x.com/omarsar0/status/2067618845926510770) |
| 3) **PreAct** - Computer-using agents drive real software through the screen, but they solve every task from scratch. Ask one to repeat a task and it re-reads the screen and re-reasons every tap, paying the full cost again. PreAct fixes this by compiling the first successful run into a small state-machine program, where states check the screen and transitions act, then replaying that program on later runs instead of invoking the agent. <br>● Compile runs into a state machine: A completed task is captured as an explicit program rather than a free-form trace, turning a one-off solution into a reusable artifact that can be executed deterministically.  <br>● Replay with no per-step model calls: Replaying the compiled program runs 8.5 to 13 times faster than the agent because it needs no per-step language-model calls on repeated tasks.  <br>● Safe by construction: At each step PreAct checks that the screen matches what the program expects before acting, and hands control back to the agent the moment something is off, and it only stores programs an independent evaluator confirms solve the task from a clean state.  <br>● Why it matters: This turns computer-using agents from interactive tools that re-reason everything into repeatable operational systems, which is exactly what is needed to deploy them on recurring real work. | [Paper](https://arxiv.org/abs/2606.17929), [Tweet](https://x.com/dair_ai/status/2067386816815387019) |
| 4) **Can LLM Agents Infer World Models?** - Can an LLM agent actually build a model of an environment it cannot see? This work makes that question gradeable through agentic automata learning. An agent has to uncover a hidden deterministic finite automaton by interacting with an oracle through two interfaces, membership queries that ask whether a string belongs to the target language, and equivalence queries that ask whether a proposed automaton is correct, which yields a clean, scalable testbed for interactive discovery. <br>● A gradeable world-model test: Casting world-model inference as DFA learning gives objective success criteria and measurable interaction efficiency, with classic automata-learning algorithms as strong, well-understood baselines.  <br>● Controlled, scalable difficulty: The size of the hidden automaton acts as a difficulty knob, so the benchmark can scale task complexity smoothly rather than relying on a fixed set of puzzles.  <br>● Agents lag classic algorithms: Current agents can sometimes perform non-trivial interactive discovery, but performance drops sharply as DFA size grows, and trajectory analyses reveal recurring failures in query planning, evidence integration, and hypothesis construction.  <br>● Why it matters: Reasoning models clearly beat non-reasoning ones here, but the large gap to classic algorithms shows that systematic, interactive world-model building is still an unsolved capability rather than a byproduct of scale. | [Paper](https://arxiv.org/abs/2606.16576), [Tweet](https://x.com/dair_ai/status/2066897342255747116) |
| 5) **From Trainee to Trainer** - Who should design the training environment for an RL agent, the practitioner or the policy itself? RL pipelines for LLMs usually rely on manually redesigned environments between stages, with practitioners guessing which configuration will best improve the current policy. This paper hands that job to the model, proposing an LLM-as-Environment-Engineer framework where the policy diagnoses its own weaknesses and proposes the next environment to train on. <br>● The policy designs its own curriculum: Instead of a human reshaping the environment between stages, the current policy analyzes failure trajectories together with contextual information and proposes modifications to the next-stage training environment configuration.  <br>● Failure-driven environment edits: Because the proposals are grounded in the policy's actual failure modes, the curriculum targets the specific gaps holding the model back rather than generic difficulty bumps.  <br>● The trainee becomes the trainer: A key finding is that the current RL checkpoint serves as a better environment engineer than the original base model, suggesting that learning to act also improves the model's ability to diagnose what it still cannot do.  <br>● Why it matters: Manual between-stage environment design is one of the least scalable parts of RL for LLMs, and letting the policy steer its own curriculum closes a slow human-in-the-loop step that has bottlenecked agentic RL. | [Paper](https://arxiv.org/abs/2606.17682), [Tweet](https://x.com/dair_ai/status/2067432115072098705) |
| 6) **OpenClaw-Skill** - Equipping LLM agents with effective skills is most of the battle in real systems, yet most skill-induction work distills one trajectory at a time, which produces narrow, brittle skills. OpenClaw-Skill introduces Collective Skill Tree Search, a tree-search-based skill construction framework that builds a structured, diverse, and generalizable tree of skills, then trains agents to actually use what it builds. <br>● Collective Skill Tree Search: Rather than distilling a single trajectory into a single skill, CSTS searches over a tree of candidate skills, using multiple models to generate and evaluate them so the library captures diverse strategies.  <br>● A structured, reusable skill tree: Organizing skills hierarchically yields competencies that generalize across tool use, multi-step reasoning, and environmental interaction instead of overfitting to one task.  <br>● Training agents to leverage skills: Building the tree is only half the work, so the framework pairs construction with a learning step that teaches agents to retrieve and apply the constructed skill hierarchy effectively.  <br>● Why it matters: Reusable skill libraries are becoming the backbone of capable agents, and moving from per-trajectory distillation to collective tree search is a concrete recipe for libraries that stay useful as tasks grow. | [Paper](https://arxiv.org/abs/2606.16774), [Tweet](https://x.com/omarsar0/status/2066898866885263491) |
| 7) **Back on Track** - Diffusion large language models generate text in a way that does not fit cleanly into the reinforcement learning recipes built for autoregressive models, and training them to reason exposes two specific problems. Rewards are sparse, so a single terminal reward fails to guide intermediate generation steps, and policy updates sometimes drift toward unnatural trajectories rather than authentic generation paths. This paper proposes Process Aligned Policy Optimization to fix both. <br>● Two failure modes named: The work isolates sparse rewards and trajectory drift as the core obstacles to stable RL training for reasoning in diffusion LLMs, rather than treating training instability as a black box.  <br>● Step-aware process rewards: PAPO converts terminal rewards into granular, step-level guidance, so intermediate denoising steps receive a learning signal instead of waiting for a single end-of-sequence score.  <br>● Entropy-guided re-enactment: At critical high-uncertainty moments, the method replays genuine generation paths, keeping updates aligned with how the model actually produces text instead of chasing artificial trajectories.  <br>● Why it matters: Diffusion LLMs are a serious alternative to autoregressive models, and giving them a stable RL recipe for reasoning, with reported gains from 4.5% to 42.2% on benchmarks like GSM8K and MATH500, helps close the reasoning gap between the two paradigms. | [Paper](https://arxiv.org/abs/2606.08501), [Tweet]() |
| 8) **AtomMem** - Long-term memory for LLM agents tends to fail in two ways: coarse summaries drift over time, and unconstrained updates corrupt what was already stored. AtomMem keeps the unit of memory small, using a Fact Executor that selectively extracts high-value atomic facts from long interactions and organizes them into hierarchical event structures and temporal user profiles, with an associative memory graph that reconnects fragmented memories at retrieval. The approach reports state-of-the-art results on the LoCoMo long-term memory benchmark. | [Paper](https://arxiv.org/abs/2606.19847), [Tweet](https://x.com/dair_ai/status/2067984002376749525) |
| 9) **Beyond Domains** - LLM web agents usually run as tool callers, reading a fresh page each turn and emitting one low-level action, so both task horizons and the number of LLM completions blow up. This work makes web skills reusable across sites with SkillMigrator, which stores induced skills as transferable interaction patterns keyed by page-layout structure rather than instruction similarity or site metadata, so a skill learned on one site fires on new sites with the same interaction shape. It cuts the average LLM-action count by 8 to 10% on WebArena and Mind2Web at comparable success rates. | [Paper](https://arxiv.org/abs/2606.17645), [Tweet](https://x.com/dair_ai/status/2067620607643246861) |
| 10) **The Stanford EDGAR Filings Dataset** - Clean, long-context documents remain scarce for pretraining, especially in finance. This release reconstructs U.S. SEC corporate and financial disclosures into layout-faithful, token-efficient MultiMarkdown, publishing 152B tokens in SEFD-v1 out of an estimated 550B-token archive spanning 18.5M filings, with less than 0.1% overlap with Common Crawl corpora. It also ships two derived benchmarks, EDGAR-Forecast for numerical forecasting and EDGAR-OCR for financial table transcription, to support financial reasoning, forecasting, and document understanding. | [Paper](https://arxiv.org/abs/2606.18192) |

---

## Top AI Papers of the Week (June 7 - June 14) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **MiniMax Sparse Attention** - Ultra-long context is now a core requirement for agents, codebase-scale reasoning, multimodal workflows, and persistent memory, but dense softmax attention still makes million-token deployment expensive. MiniMax Sparse Attention (MSA) tackles this by adding blockwise sparsity on top of Grouped Query Attention, with a lightweight routing branch that chooses which key-value blocks each query group should actually attend to. <br>● Two-branch attention design: The Index Branch scores the full causal context and selects Top-k key-value blocks independently for each GQA group, while the Main Branch performs exact sparse attention only over those selected blocks.  <br>● Hardware-aware implementation: The paper co-designs the sparse pattern with GPU kernels, using exp-free Top-k selection and KV-outer sparse attention to improve tensor-core utilization under block-granular access.  <br>● Large speedups at scale: On a 109B-parameter natively multimodal model, MSA matches GQA performance while reducing per-token attention compute by 28.4x at 1M context. The paired kernel reaches 14.2x prefill and 7.6x decoding wall-clock speedups on H800.  <br>● Why it matters: Long context is only useful if it can be served cheaply. MSA is compelling because it keeps the mechanism simple, trains it directly into a production-scale model, open-sources the inference kernel, and powers the released MiniMax-M3 model. | [Paper](https://arxiv.org/abs/2606.13392), [Tweet](https://x.com/MiniMax_AI/status/2065436935188058208) |
| 2) **Self-Harness** - Most agent scaffolds are built once by hand and then frozen, even as the underlying models keep changing. This paper introduces Self-Harness, a paradigm where an LLM agent improves its own operating harness, the prompts, tools, memory, and orchestration around the base model, without human engineers or a stronger external agent. Because every model fails in its own way, the system mines those model-specific weaknesses and turns them into concrete, executable harness edits rather than generic advice. <br>● A three-stage self-improvement loop: Self-Harness runs Weakness Mining, which clusters execution traces into model-specific failure patterns, then Harness Proposal, which generates diverse but minimal edits tied to those failures, then Proposal Validation, which accepts edits only after regression testing on held-in and held-out splits.  <br>● Consistent gains across base models: On Terminal-Bench-2.0, held-out pass rates rise for every model tested. MiniMax M2.5 improves from 40.5% to 61.9%, Qwen3.5-35B-A3B from 23.8% to 38.1%, and GLM-5 from 42.9% to 57.1%.  <br>● Weaknesses become edits: Rather than appending generic instructions, the loop converts each observed failure mode into a targeted change to memory, tools, or prompts, with reported relative improvements as high as 138%.  <br>● Why it matters: As models proliferate and evolve, hand-tuning a bespoke harness for each one does not scale. Self-Harness shows the scaffold itself can be made to adapt, closing the gap between a frozen harness and the model it wraps. | [Paper](https://arxiv.org/abs/2606.09498), [Tweet](https://x.com/omarsar0/status/2064429834999304247) |
| 3) **Agents' Last Exam** - From Berkeley RDI, Agents' Last Exam (ALE) is a living benchmark built to measure whether agents can do economically valuable work, not just score well on academic tests. It was assembled with more than 250 industry experts and maps over 1,000 verifiable tasks to the U.S. federal occupational taxonomy, organized as 55 subfields across 13 industry clusters. Every task has an objective, checkable outcome, so there is no subjective human grading, and the pool is designed to keep growing as new workflows are onboarded. <br>● Grounded in real occupations: Tasks are defined against O*NET and SOC 2018 and span non-physical industries, deliberately targeting the professional workflows where agents would actually be deployed rather than puzzle-style problems.  <br>● Three difficulty tiers: Work is split into Near-Term, Full-Spectrum, and Last-Exam tiers, letting the benchmark track both near-term usefulness and the long tail of hard, multi-step jobs.  <br>● Far from saturated: The hardest tier sits at just a 2.6% average full pass rate across mainstream harnesses, and even strong setups like Codex with GPT-5.5 score below 50% on the easiest tier and under 10% on the hardest.  <br>● Why it matters: Strong scores on existing benchmarks have not translated into economically meaningful deployment. ALE reframes evaluation around verifiable, expert-curated work, giving a moving target that should resist saturation as agents improve. | [Paper](https://arxiv.org/abs/2606.05405), [Tweet](https://x.com/dair_ai/status/2062916866235068607) |
| 4) **How AI Agents Reshape Knowledge Work** - This economics paper, drawing on large-scale production data from Perplexity, studies how the shift from conversational assistants to autonomous agents is reshaping knowledge work. It compares Search, a conversational assistant, with Computer, a general-purpose agent system, along three dimensions: autonomy, efficiency, and the scope of tasks people take on. The framing is a cost-structure model in which agents carry higher fixed and delegation costs but lower per-step marginal costs, so they win once tasks are complex enough. <br>● Autonomy looks different in practice: Computer performs around 26 minutes of autonomous machine work per session versus roughly 33 seconds for Search, and per-query dissatisfaction is 55% lower on the agent, 1.3% against 2.9%.  <br>● Large efficiency gains: On matched tasks, Computer cuts completion time from 269 to 36 minutes, an 87% reduction in time and about a 94% reduction in cost relative to humans working with Search alone.  <br>● Scope shifts upward: Agent queries are more cognitively complex, 71% abstract or non-routine versus 53%, with twice as much create-level work, and they bundle interdependent subtasks that cross occupational boundaries.  <br>● Why it matters: The data supports a clean prediction. As the fixed costs of delegation fall, agents move the affordable value frontier toward higher-value, multi-step knowledge work, which is exactly where adoption grew fastest, reaching 84 times its first-week volume over the study. | [Paper](https://arxiv.org/abs/2606.07489), [Tweet](https://x.com/omarsar0/status/2064076252584222933) |
| 5) **Agentopia** - Agentopia is one of the most ambitious agent-society testbeds yet, a 79-page release that drops 100 LLM agents into a persistent world and lets them live, form relationships, and pursue goals over 10 simulated years, a horizon orders of magnitude longer than prior day-level work. Beyond observing emergent social behavior, the authors use the simulation as a training signal, optimizing models toward a life reward that reflects human well-being via rejection sampling. <br>● Long-horizon by design: Where earlier agent societies ran at the granularity of days, Agentopia simulates a decade of life per world, surfacing unscripted social strategies and interpersonal dynamics that only appear over long timescales.  <br>● Simulation as a training signal: The life-reward metric is used to fine-tune more anthropomorphic models, and the improvements transfer beyond the simulation to downstream role-playing benchmarks rather than staying trapped in the sandbox.  <br>● Measured gains: Trained agents improve overall CoSER Test performance by 15.6%, with the biggest jumps in Anthropomorphism at 23.7% and Character Fidelity at 16.4%, and they are respected by 24.2% more peers and liked by 15.9% more.  <br>● Why it matters: A single 10-year, 100-agent run consumes 13.7 billion tokens across 567,000 LLM calls. That scale is a statement about where agent research is heading: living, learning populations as both an object of study and a source of training data. | [Paper](https://arxiv.org/abs/2606.07513), [Tweet](https://x.com/dair_ai/status/2064075015960875347) |
| 6) **The Geometry of On-Policy Distillation** - On-policy distillation (OPD) has become one of the most discussed post-training recipes of the year, but it has mostly been treated as a black box sitting somewhere between supervised fine-tuning and RL. This paper opens it up, characterizing how OPD changes a model's weights at the level of parameter geometry, and argues OPD is not a midpoint between SFT and RLVR but its own distinct kind of update. <br>● It touches fewer weights: Compared with SFT, OPD updates affect far fewer parameters and largely avoid the dominant principal directions of weight space, which helps explain its sample efficiency.  <br>● Early subspace locking: OPD's cumulative updates rapidly collapse into a narrow, low-dimensional subspace early in training, rather than spreading across many directions as SFT does.  <br>● That subspace is functionally sufficient: Constraining training to the early-formed subspace preserves OPD performance but substantially degrades SFT, showing the small subspace genuinely carries the useful signal rather than being an artifact.  <br>● Why it matters: Knowing where in weight space OPD does its work turns a popular but poorly understood recipe into something with a mechanistic account. That makes the method easier to reason about, combine with other objectives, and improve deliberately instead of by trial and error. | [Paper](https://arxiv.org/abs/2606.07082) |
| 7) **Lookahead Sparse Attention** - Long-context decoding is bottlenecked by the KV cache, which grows with every token and quickly dominates memory at extreme context lengths. This work, branded around DeepSeek-V4, introduces Lookahead Sparse Attention (LSA), which avoids storing the full KV cache by predicting which parts of the context future decoding will actually need and retaining only those query-critical chunks. <br>● A learned, lightweight indexer: Instead of keeping everything, a small indexer proactively selects the KV chunks that matter for upcoming generation, so the physical cache stays small without discarding information the model will need.  <br>● Backbone-free training: A decoupled training strategy lets the indexer be trained on its own without loading the full backbone model, cutting the cost of adding the mechanism to a large model.  <br>● Big cache savings, no quality loss: LSA shrinks the physical KV cache to 13.5% of the full-context baseline while slightly improving accuracy by 0.6% on average, and at 500K-token contexts it suppresses more than 90% of KV-cache overhead without destabilizing reasoning.  <br>● Why it matters: Ultra-long context is increasingly the difference between a toy demo and a usable system, and memory is the wall. Predicting what context you will need, rather than keeping all of it, is a practical route to long context that fits in real hardware budgets. | [Paper](https://arxiv.org/abs/2606.09079) |
| 8) **Latent Spatial Memory** - Video world models struggle to stay consistent over long horizons because explicit 3D memory usually requires an expensive pixel-space loop. Mirage instead stores scene information directly in diffusion latent space, using depth-guided back-projection and latent-space warping to maintain persistent spatial memory. The approach reports up to 10.57 times faster end-to-end generation and 55 times lower memory use than explicit 3D-memory baselines while improving long-horizon spatial consistency. | [Paper](https://arxiv.org/abs/2606.09828) |
| 9) **The Consistency Illusion** - Multi-agent debate is often judged by whether the agents end up agreeing, but this paper shows that output-level consensus can hide deep disagreement in the reasoning that produced it. The authors abstract agents' reasoning traces and decisions into four states along two axes, reasoning similarity and conclusion agreement, and flag divergent agreement, where agents reach the same answer through very different paths. Across 600 content-moderation items, divergent agreement appeared in 118 cases and separated cleanly from genuine disagreement states with a Cohen's d of 0.80, and routing on these categories beat divergence-only methods at flagging high-disagreement cases. | [Paper](https://arxiv.org/abs/2606.04223), [Tweet](https://x.com/dair_ai/status/2064395355220029696) |
| 10) **Beyond Scalar Rewards** - Reward models usually compress a judgment into a single scalar, but this paper argues human preferences are better captured as score distributions, and proposes Z-Reward, which internalizes reasoning into a predicted distribution before scoring. A large vision-language teacher does the reasoning-heavy judgment and is distilled into a compact student for efficient deployment, with the 27B teacher reaching 89.6% human-preference accuracy and the 9B student nearly matching it at 88.6%. Used as a reinforcement learning signal, it delivers a 41.3% net preference improvement over a supervised baseline, beating GRPO and other reward methods. | [Paper](https://arxiv.org/abs/2606.09076) |

---

## Top AI Papers of the Week (May 31 - June 7) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **Self-Revising Discovery Systems** - From MIT, this paper argues that genuine scientific discovery is not answer generation but a change in the search space itself, and that an AI scientist must perceive that shift without being told. It develops a category-theoretic framework in which evidence, artifacts, operations, and verifiers are typed, and discovery is defined as a principled revision of that representational regime rather than more search within a fixed one. <br>● Discovery means changing the regime: The system is built to detect when the representational regime should change and to revise it autonomously. That reframes an AI scientist from a faster searcher into something that can move the boundaries of the space it searches.  <br>● A typed, categorical foundation: Evidence, artifacts, operations, and verifiers are formally typed. Old results are carried into the new regime by functorial transport, and what counts as genuine discovery is the residual content that transport alone cannot explain.  <br>● Description-length gates keep it honest: Proposed revisions are accepted only when they reduce total description length, which separates real structural gains from mere added complexity. In one run, 388 proposals yield just 25 accepted revisions, a deliberately strict 6.4% rate.  <br>● Why it matters: Two concrete instantiations, protein-mechanics modeling and a knowledge-computation graph with typed skills and validation checkpoints, show category theory serving as both a formal language and an engineering spec. It is a more principled blueprint for autonomous discovery than search-only AI scientists. | [Paper](https://arxiv.org/abs/2606.01444), [Tweet](https://x.com/ProfBuehlerMIT/status/2062865983459475830) |
| 2) **Disentangling Agent Self-Evolution** - This paper asks a question every agent builder eventually hits: if an agent rewrites its own harness, does a stronger model make a better self-evolving agent? The answer is no, and the reason is that "self-evolution" is actually two separate abilities that scale very differently. The work separates harness-updating, where an evolver model writes edits to memory, tools, prompts, and skills, from harness-benefit, where a solver model actually exploits those edits on the task. <br>● Updating is flat across model tiers: The quality of harness edits barely depends on model strength. Updates written by Qwen3.5-9B yield gains comparable to those from Claude Opus 4.6, so paying for a frontier model on the evolver side buys almost nothing.  <br>● Benefit is non-monotonic: The ability to use a better harness follows a curve. Weak models gain little, mid-tier models benefit most, and the strongest models benefit less than mid-tier ones, often because they already solve the task without the scaffold.  <br>● Failure modes are concrete: Weaker solvers either fail to activate the relevant harness component or follow its instructions inconsistently, which is why their gains stay small even when the edits themselves are good.  <br>● Why it matters: The practical lever is to put a cheap model on the evolver and spend your capability budget on the solver. System design, not raw model scale, is doing most of the work in agent self-improvement. | [Paper](https://arxiv.org/abs/2605.30621), [Tweet](https://x.com/omarsar0/status/2061460266186125703) |
| 3) **LEAP** - New research from Google shows how far a custom agent harness can push a general-purpose model on formal mathematics. LEAP wraps a general LLM in an agentic scaffold that grounds every step in the Lean compiler and iterates against verifier feedback. Rather than fine-tuning a specialized prover, it leans on informal reasoning, instruction following, and self-refinement, then forces every formal step through a compiler check before moving on. <br>● Decompose, then verify: The scaffold takes the natural form of proof decomposition and verifier-guided refinement. The model breaks a hard theorem into subgoals, drafts an informal blueprint, and the Lean compiler checks each formal step, turning vague reasoning into machine-checkable proof.  <br>● Putnam solved in full: On the 2025 Putnam Competition, LEAP solves all 12 problems, matching recent breakthroughs from dedicated frontier math models without any math-specific training of the base LLM.  <br>● Large jump on IMO-level proofs: On Lean-IMO-Bench, LEAP lifts the one-shot formal solve rate of general-purpose LLMs from below 10% to 70%, surpassing the 48% set by a specialized, gold-medal-caliber IMO system.  <br>● Why it matters: This is strong evidence that a well-built harness, not a bespoke model, can close the gap on one of the hardest reasoning domains. The leverage sits in the scaffold and the verifier loop around a general model. | [Paper](https://arxiv.org/abs/2606.03303), [Tweet](https://x.com/omarsar0/status/2062187813626675567) |
| 4) **Scaling Laws for Agent Harnesses** - Most harness tuning treats every token and tool call as if volume is what counts. This paper shows that it mostly does not, and introduces Effective Feedback Compute (EFC), a trace-level scaling coordinate that credits feedback only when it is informative, valid, non-redundant, and retained for later decisions, then normalizes by task demand. <br>● Raw budget barely predicts success: In controlled scaling, raw tokens and tool calls explain limited variation in outcomes, with R-squared of 0.33 and 0.42. The usual cost proxies are weak predictors of whether the agent actually succeeds.  <br>● Effective feedback nearly explains everything: Oracle-EFC normalized by task demand reaches an R-squared of 0.99. Once you measure feedback that is genuinely useful and retained, the scaling behavior becomes almost fully predictable.  <br>● Quality beats quantity at fixed budget: In matched-budget interventions, improving feedback quality raises success from 0.27 to 0.90 while raw cost and tool calls stay fixed. The win comes from better feedback, not more of it.  <br>● Why it matters: Harness scaling is governed less by how much compute you spend than by how efficiently raw budget converts into durable, task-sufficient feedback. That reframes harness engineering as a feedback-quality problem and gives a coordinate to optimize against. | [Paper](https://arxiv.org/abs/2605.29682), [Tweet](https://x.com/omarsar0/status/2060371848010019001) |
| 5) **AutoLab** - Can frontier models actually grind on a hard engineering problem the way a good researcher does? AutoLab is a benchmark for ultra long-horizon, closed-loop optimization built to answer that. It contains 36 realistic, expert-curated tasks across four domains: system optimization, puzzle and challenge, model development, and CUDA kernel optimization. Each task hands the agent a correct but deliberately suboptimal baseline and asks it to improve within a strict wall-clock budget. <br>● Persistence beats a strong start: The dominant predictor of final performance is not the quality of the initial solution but the agent's persistence in iterative refinement. Models that keep probing and improving win, regardless of where they began.  <br>● Most models quit early: While Claude Opus 4.6 shows strong long-horizon optimization, most frontier models, including several proprietary ones, either terminate prematurely or burn their budget with minimal progress.  <br>● Time awareness is the gap: The results point to time-awareness and sustained iteration, not raw single-shot capability, as the missing ingredient for truly capable long-horizon agents.  <br>● Why it matters: Day-one benchmarks reward clever first attempts, but real research and engineering reward stamina. AutoLab measures the thing that actually separates agents on multi-hour tasks, and the benchmark, harness, and task artifacts are open-sourced. | [Paper](https://arxiv.org/abs/2606.05080), [Tweet](https://x.com/dair_ai/status/2062570078705688777) |
| 6) **Reusable Context Engineering** - Context bloat quietly kills long-horizon runs, and the usual fixes are baked into an agent's own prompt or weights, so they do not transfer. AdaCoM takes a different route: it trains a separate external model to manage the context of a frozen agent through flexible modification actions, optimized end-to-end with reinforcement learning. The agent never changes; only the context flowing into it does. <br>● An external context manager: A dedicated model edits the agent's working context, deciding what to keep, compress, or drop. Because it sits outside the agent, it can be reused as a drop-in component rather than re-engineered per backbone.  <br>● Trained with reinforcement learning: The manager is optimized end-to-end against task outcomes, learning context-editing policies instead of relying on hand-written heuristics or fixed truncation rules.  <br>● Transfers across similar agents: Transfer experiments show AdaCoM generalizes most effectively across agents of similar capability, pointing toward genuinely reusable context managers. It improves web search and deep research by preserving task constraints and progress while pruning stale content.  <br>● Why it matters: Treating context management as a separate, trainable, transferable module decouples it from the agent itself. That is a cleaner abstraction than stuffing context logic into every prompt, and it fixes bloat from the outside without touching the underlying model. | [Paper](https://arxiv.org/abs/2605.30785), [Tweet](https://x.com/dair_ai/status/2061455253325971789) |
| 7) **Learn From Your Own Latents** - LLMs learn by predicting tokens, while world models like JEPA and data2vec learn by predicting their own internal representations. This paper provides a sample-complexity theory for why the second approach can be dramatically more data-efficient, using a tractable probabilistic context-free grammar as the analytical setting where compositional structure can be measured exactly. <br>● Exponential gap in data efficiency: Predicting your own latents requires a number of samples that is constant in the tree depth L, whereas supervised and token-based self-supervised learning need samples that grow exponentially in L. The advantage is structural, not incidental.  <br>● Why latents win: Latent targets expose the compositional, hierarchical structure of the data directly, so the learner does not have to reconstruct it from surface tokens. That is the mechanism behind the data-efficiency gain.  <br>● Hierarchy may be implicit: The analysis suggests that explicit hierarchical stacking, as in H-JEPA, can be largely redundant, because methods like data2vec already learn hierarchical structure implicitly.  <br>● Why it matters: As token-prediction scaling laws press against data limits, this gives a principled argument for self-supervised objectives that predict abstractions instead of tokens. It is a theoretical foundation for why world-model-style training could beat brute-force next-token prediction on sample efficiency. | [Paper](https://arxiv.org/abs/2605.27734), [Tweet](https://x.com/MatthieuWyart/status/2061317203857739846) |
| 8) **A Primer on Post-Training Reasoning Data** - This primer is the first to pull the scattered post-training reasoning-data literature into one place, synthesizing over 150 public studies and system reports that previously lived across dataset papers, RL write-ups, and lab reports. It organizes the field around four questions: what data objects exist, what makes them useful, how they are constructed, and how they scale. The key reframing is that a reasoning-data item is more than a prompt-response pair: it packages a problem or state, model behavior, judging feedback, and attribution metadata, with usefulness defined relative to the verifier and the rest of the corpus rather than in isolation. | [Paper](https://arxiv.org/abs/2606.02113), [Tweet](https://x.com/dair_ai/status/2062189321697083768) |
| 9) **State-Externalizing Harnesses** - Harness-1 is a 20B search agent trained with reinforcement learning inside a stateful harness that offloads routine bookkeeping to the environment. The argument is that search agents are usually trained as policies over a growing transcript, forcing RL to optimize both genuine search decisions and recoverable state like which evidence is useful or which claims are checked. Harness-1 moves that state out of the policy and into an environment-side working memory of candidate pools, an importance-tagged curated set, compact evidence links, and verification records. The 20B agent reaches an average curated recall of 0.730 across eight retrieval benchmarks, beating open-source baselines by 11.4 points and matching or outperforming much larger frontier searchers, with stronger generalization on unseen domains. | [Paper](https://arxiv.org/abs/2606.02373), [Tweet](https://x.com/dair_ai/status/2061825437693841651) |
| 10) **Do More Agents Help?** - This paper studies whether adding agents actually makes a single LLM-driven multi-agent system better, using a Sequential Iterative Multi-Agent System (SIMAS) framework. The finding is that performance does not scale monotonically with agent count but follows a pattern of diminishing returns, with degradation eventually driven by coordination overhead. Effective systems still require a capable base model, the optimal number of agents depends on the task type, and collective intelligence turns out to be a product of strategic interaction design rather than a guaranteed outcome of agent plurality. The takeaway for builders is to design the interaction, not just stack more agents. | [Paper](https://arxiv.org/abs/2606.00655), [Tweet](https://x.com/omarsar0/status/2061826427461464405) |

---

## Top AI Papers of the Week (May 24 - May 31) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **SkillOpt** - Microsoft Research treats a compact natural-language skill document as the trainable state of a frozen agent, then learns that document through rollouts, reflection, and bounded edits gated by held-out validation. The argument is direct: most engineers handwrite agent skill docs and hope they generalize, when the doc itself should be optimized like a parameter. SkillOpt reframes the SKILL.md file as an external parameter of a model whose weights never change. <br>● The skill doc as a trainable parameter: An optimizer model proposes validation-gated edits to the skill file, adding, deleting, or replacing instructions. A textual learning rate controls how aggressively each round rewrites the document, with batch and momentum reported in text space rather than gradient space.  <br>● Validation gates instead of hope: Every edit must pass a held-out check before it is kept. This turns skill authoring into a measurable optimization loop with a real objective, rather than prompt tweaking guided by intuition.  <br>● 52 out of 52 wins: SkillOpt beats Trace2Skill, TextGrad, GEPA, EvoSkill, human-written skills, and one-shot skills across 6 benchmarks and 7 target models. It adds roughly +23.5 points on GPT-5.5 in direct chat, +24.8 in the Codex loop, and +19.1 in Claude Code from the no-skill baseline.  <br>● Why it matters: If the skill document is the thing you optimize, the bottleneck shifts from base-model capability to how well you can train the natural-language state around a frozen agent. That is a cheap, model-agnostic lever most teams are leaving on the table. | [Paper](https://arxiv.org/abs/2605.23904), [Tweet](https://x.com/omarsar0/status/2058936160291004483) |
| 2) **Compiling Agentic Workflows into Weights** - This paper shows that a full agentic workflow can be distilled into the weights of a small model and run at roughly two orders of magnitude lower inference cost while preserving near-frontier task quality. Instead of keeping an external orchestrator above the LLM, the procedure is compiled into the weights of a fine-tuned model, producing what the authors call a subterranean agent. <br>● The whole workflow, not just the answer: The compiled procedure includes multi-step LLM calls, tool invocations, intermediate scratchpads, and decision points. The student internalizes the orchestration logic rather than only imitating final outputs.  <br>● Orchestrator dissolved into the model: Classic agent frameworks run a planner loop above the model on every request. Compiling that loop into weights removes the per-call orchestration overhead, which is where most of the cost and latency live.  <br>● Near-frontier quality at 100x less cost: Across the evaluated tasks, the distilled small model stays close to the original workflow's quality while cutting inference cost by about two orders of magnitude. The savings come from collapsing many model calls into one forward pass.  <br>● Why it matters: Most production agents pay repeatedly for an orchestration loop they run thousands of times a day. If that loop can be compiled once into a cheap model, the economics of deploying agentic systems change substantially, especially for high-volume narrow workflows. | [Paper](https://arxiv.org/abs/2605.22502), [Tweet](https://x.com/dair_ai/status/2057846601843146760) |
| 3) **AutoScientists** - AutoScientists, from Harvard, is a decentralized team of AI agents for long-running computational science that drops the central planner entirely. Rather than following one research trajectory coordinated from the top, agents self-organize around promising hypotheses, critique each other's proposals before spending experimental compute, and record both successes and failures so the system avoids redundant exploration as evidence accumulates over hours or days. <br>● No central planner: Agents interpret shared experimental state, form teams around promising directions, and reorganize when progress stalls. Coordination emerges from a common state rather than a top-level controller, which sustains parallel search instead of a single thread.  <br>● Evaluate before you spend: Proposals are critiqued and scored before any experimental compute is allocated. This gating reduces wasted trials and keeps the system from repeating dead ends that an individual agent would otherwise revisit.  <br>● Strong results on real science tasks: On BioML-Bench, 24 biomedical ML tasks spanning imaging, protein engineering, single-cell omics, and drug discovery, AutoScientists reaches 74.4% mean leaderboard percentile, an improvement of +8.33% over the strongest prior AI agent.  <br>● Why it matters: Most multi-agent research systems still funnel decisions through a planner that becomes a bottleneck. Decentralized self-organization with explicit failure-sharing is a different blueprint for long-horizon scientific search, and it holds up on hard biomedical benchmarks. | [Paper](https://arxiv.org/abs/2605.28655), [Tweet](https://x.com/dair_ai/status/2060028833080987668) |
| 4) **Language Models Need Sleep** - Attention scales badly with context length, so long-horizon agents keep paying a growing cost as their context grows. This paper studies a sleep-like consolidation mechanism: the model periodically converts recent context into persistent fast weights, then clears its key-value cache. During the sleep phase it performs offline recurrent passes over the accumulated context and updates fast weights in its state-space blocks through a learned local rule. <br>● Consolidate, then clear the cache: Recent context is folded into fast weights stored in the model's SSM blocks before the KV cache is discarded. The agent keeps what it learned without carrying the full attention bill into every future step.  <br>● Compute moves to sleep, latency stays at wake: The extra work happens offline during consolidation, so wake-time prediction keeps its low latency. The tradeoff is explicit and controllable rather than hidden in a ballooning context window.  <br>● More sleep helps the hardest cases: Increasing sleep duration improves performance, with the largest gains precisely on tasks that require the most complex reasoning over long histories. The mechanism buys the most where naive attention struggles most.  <br>● Why it matters: Long-horizon agents are the first systems to feel the quadratic cost of context. A biologically inspired consolidation step gives a principled alternative to ever-longer context windows, and it maps cleanly onto the state-space architectures already used for efficiency. | [Paper](https://arxiv.org/abs/2605.26099), [Tweet](https://x.com/dair_ai/status/2059333792775745619) |
| 5) **Adapting the Interface, Not the Model** - When a frozen LLM agent repeatedly fails in a deterministic, rule-governed environment, do you have to retrain the model? Life-Harness argues no. Many failures come from mismatches at the model-environment interface, not from the model's reasoning, so the fix belongs in the runtime harness. Life-Harness is a lifecycle-aware harness that improves frozen agents without touching model weights or the evaluation environment. <br>● Failures become reusable interventions: Recurring errors are turned into runtime fixes across four areas: action realization, environment contracts, trajectory regulation, and procedural skills. Each fix is a harness-level patch the agent reuses on later attempts.  <br>● Model frozen, environment intact: Nothing about the model or the benchmark changes. Only the interface between them adapts, which keeps the approach drop-in for any backbone and avoids the cost and risk of fine-tuning.  <br>● Broad, consistent gains: Across 7 deterministic agent benchmarks and 18 model backbones, Life-Harness improves 116 of 126 model-environment settings, with an 88.5% average relative improvement. The effect holds across model scales rather than helping only weak models.  <br>● Why it matters: This is more evidence for the code-as-harness thesis: a large share of agent failures are interface problems that harness engineering can fix without retraining. For builders, the leverage is in the runtime, not the model. | [Paper](https://arxiv.org/abs/2605.22166), [Tweet](https://x.com/omarsar0/status/2058208914148389083) |
| 6) **The Efficiency Frontier** - Context costs dominate production LLM bills, and the right strategy depends on how often preprocessing gets reused. This paper models context-strategy selection as a deployment-aware optimization problem that jointly accounts for task performance, token cost, and reuse, then uses it to compare retrieval-based and preprocessing-based approaches under realistic constraints. <br>● A reuse-aware cost model: A parameterized log-utility metric captures diminishing returns from more context while charging an amortized preprocessing cost. Varying a reuse parameter lets the framework compare strategies under different deployment patterns on equal footing.  <br>● Distinct operating regimes: The analysis reveals clean transition boundaries between retrieval and preprocessing strategies. Which one wins flips depending on how many times you reuse the preprocessed context, so a single default is rarely optimal.  <br>● Real token savings: On 5,000 HotpotQA instances, deployment-aware optimization cuts effective token usage by roughly 25% at comparable performance, and amortized memory compression achieves over 50% lower token cost relative to full-context.  <br>● Why it matters: Most teams pick a context strategy once and pay for it on every request. Treating context management as an explicit cost-performance optimization turns a guess into a measurable decision, with double-digit savings available on common workloads. | [Paper](https://arxiv.org/abs/2605.23071), [Tweet](https://x.com/dair_ai/status/2058948732658626789) |
| 7) **Forecasting Scientific Progress with AI** - Can frontier models predict where science is going? This work introduces CUSP, a cutoff-conditioned benchmark built from 4,760 real scientific events across multiple disciplines, each grounded against a verified knowledge cutoff. For every event, models are tested on four tasks: feasibility assessment, mechanistic reasoning, generative solution design, and temporal prediction. The headline is sobering: models recognize plausible directions but cannot forecast outcomes. <br>● Recognition is not foresight: Models can identify plausible research directions when choosing among competing candidates, but they fail to reliably predict whether an advance will actually be realized, and they systematically misestimate when it will happen.  <br>● Domain-dependent, and timing is hardest: Performance is highly heterogeneous across fields, with the timing of AI progress more predictable than advances in biology, chemistry, and physics. Temporal prediction is the weakest skill across the board.  <br>● Not just a training-cutoff artifact: Performance is largely insensitive to whether an event falls before or after the model's training cutoff. Extra pre-cutoff knowledge helps but does not close the gap to full-information settings, and that gap widens for high-citation advances.  <br>● Why it matters: Models also show systematic overconfidence and strong response biases, which means unreliable uncertainty estimates. As labs lean on AI to triage research bets, CUSP gives a controlled way to measure where it helps, surfacing directions, and where it fails, predicting outcomes. | [Paper](https://arxiv.org/abs/2605.22681), [Tweet](https://x.com/dair_ai/status/2058215140789797204) |
| 8) **Your Agents Are Aging Too** - AgingBench is a longitudinal reliability benchmark for agent lifespan engineering, built on the observation that long-lived agents are still evaluated like freshly initialized models. It organizes agent degradation into four mechanisms: compression aging, where write-time summarization drops future-relevant details; interference aging, where accumulated similar memories crowd out the target fact; revision aging, where changed or derived state is not updated correctly; and maintenance aging from routine lifecycle events. Using a temporal dependency DAG to encode cross-session structure, it produces aging curves over an operational lifetime rather than a single day-one score, and points to where repair should target. | [Paper](https://arxiv.org/abs/2605.26302), [Tweet](https://x.com/omarsar0/status/2059689897523642510) |
| 9) **Harnesses Are Not Uniformly Better** - This paper studies LLM agent harnesses through the lens of inference-time trajectory alignment, separating a harness into two mechanisms: task decomposition, which structures a task into sub-goals, and guided execution, which reshapes local action distributions during execution. The key finding is that more elaborate harnesses are not uniformly better. Increasing decomposition or guidance can improve execution but can also reduce final task success, producing concrete failure modes like over-decomposition, over-pruning, and hallucinated execution. Strikingly, partial harnesses that specify only the initial steps and leave the rest to the agent can reach a higher pass rate than fully structured workflows. | [Paper](https://arxiv.org/abs/2605.21516), [Tweet](https://x.com/dair_ai/status/2059691141302542445) |
| 10) **Epicure** - Epicure trains a family of multilingual ingredient embeddings from scratch on 4.14 million recipes aggregated from 11 sources across seven languages, with raw ingredient strings normalized to 1,790 canonical entries via an LLM-augmented pipeline. It ships three skip-gram (Metapath2Vec) variants that share architecture but differ in what they walk: recipe co-occurrence only, chemical-compound structure from FlavorDB only, or a blend of both, placing each model at a different point on the chemistry-versus-recipe-context spectrum. The result is a compact, downloadable map of the emergent geometry of food, a clean reminder that representation learning generalizes well beyond text into surprisingly everyday domains. | [Paper](https://arxiv.org/abs/2605.22391), [Tweet]() |

---

## Top AI Papers of the Week (May 18 - May 24) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **Code as Agent Harness** - A 100+ page survey treating the agent harness as a first-class research object rather than glue around an LLM. The authors argue that code-as-harness is the most promising path to general-purpose agency, and that future agent systems should satisfy four properties: executable, inspectable, stateful, and governed. The report consolidates methods, applications, and open problems across the harness layer. <br>● Harness engineering as a discipline: The paper frames harness design as a science distinct from model training, with its own primitives, failure modes, and evaluation criteria. The taxonomy gives a vocabulary for comparing systems that has been missing in prior agent literature.  <br>● Four-property test for production agents: Executable, inspectable, stateful, and governed. Each property maps to a class of operational concerns. The authors use it to audit current open-source agent frameworks and identify where defaults fall short.  <br>● Code as the unifying substrate: Across browsing, tool use, and multi-step reasoning, harnesses that compile decisions into code consistently outperform JSON-call orchestration on the surveyed benchmarks. The paper traces this back to determinism, composability, and inspectability of the resulting traces.  <br>● Why it matters: If code-as-harness is the right substrate, then the next round of agent-system progress will come from harness-level innovation rather than from new base models. The survey gives builders a structured reference for that work. | [Paper](https://arxiv.org/abs/2605.18747), [Tweet](https://x.com/omarsar0/status/2056764334181884158) |
| 2) **OpenAI Disproves the Unit Distance Conjecture** - An OpenAI internal reasoning model produced a counterexample to Erdős's 1946 unit distance conjecture, the first time an AI system has autonomously resolved a prominent open problem in mathematics. For nearly 80 years, mathematicians believed square grids were essentially optimal for placing n points to maximize unit-distance pairs. The new construction beats grids using an infinite unramified tower of totally real number fields with 3-power Galois groups, producing n-point sets with more than n^(1.014) unit distances. A human-verified companion paper was prepared by nine external mathematicians including Noga Alon, Tim Gowers, and Melanie Matchett Wood. <br>● First autonomous resolution of a central open problem: The proof was discovered without human guidance on the mathematical substance. External mathematicians then verified, digested, and rewrote it for publication.  <br>● Deep number theory, not search: The construction uses Golod-Shafarevich theory and Galois cohomology rather than enumerative or brute-force search. The model selected and combined tools from algebraic number theory that are far from the typical training distribution for math problem solving.  <br>● Verified by the field's experts: Nine external mathematicians, including some of the conjecture's harshest prior critics, verified the proof. The companion paper presents a digested, human-verified version of the AI-generated counterexample.  <br>● Why it matters: A model autonomously closing an 80-year-old open problem changes the prior on what frontier reasoning systems can contribute to research mathematics. It also raises practical questions about credit, verification, and how the math community will integrate AI-discovered results. | [Paper](https://arxiv.org/abs/2605.20579), [Tweet](https://x.com/OpenAI/status/2057176201782075690) |
| 3) **Memory as a Model** - MeMo augments any frozen LLM with a separately trained memory model that stores, retrieves, and integrates facts on the base model's behalf. Memory updates are decoupled from base-model weight updates, so the system supports continual learning without catastrophic forgetting, a property RAG fails to deliver because a vector store is just a database with a learned encoder bolted on. <br>● Memory as a learned subsystem: MeMo has explicit read, write, and integrate interfaces rather than relying on the context window. The position is that memory in agents should be modular, learned, and gated.  <br>● Decoupled update schedule: New facts are absorbed through the memory model's training loop without touching backbone weights. This makes weekly knowledge updates feasible without retraining and without vector-DB churn.  <br>● Continual-learning robustness: Across the evaluated tasks, the system retains old knowledge while ingesting new knowledge, addressing a known failure mode of fine-tuning and a known limitation of retrieval-based memory.  <br>● Why it matters: Most production agent systems still bolt a vector store onto an LLM and call it memory. MeMo proposes that memory should be a trained component with explicit interfaces, which has implications for how long-running agent platforms are architected. | [Paper](https://arxiv.org/abs/2605.15156), [Tweet](https://x.com/dair_ai/status/2057182105671750047) |
| 4) **AIRA** - Meta's AIRA is an agent system that autonomously discovers neural architectures, producing models that beat Llama 3.2 at 350M, 1B, and 3B scales under a 24-hour compute budget. The search is split across two specialized agents: AIRA-Compose searches macro architecture, and AIRA-Design implements the low-level mechanisms. The split outperforms a single end-to-end agent on this non-toy search problem. <br>● Two-agent decomposition: A planner picks structure; an implementer fills in mechanisms. This pattern generalizes well beyond neural architecture search to pipeline assembly, query planning, prompt scaffolding, and tool-use programs.  <br>● Beats Llama 3.2 at three scales under budget: Discovered architectures match or exceed Llama 3.2 at 350M, 1B, and 3B parameter scales within a 24-hour compute budget for the search itself. That is competitive with months of human-led ablation studies.  <br>● Search not synthesis: The discovered models are not LLM-written code patches grafted into a framework. They are full architectures discovered through structured search guided by the two-agent loop.  <br>● Why it matters: If agentic search can produce competitive architectures end to end, then NAS and large parts of the ML research workflow become candidates for automation by agent systems rather than by hand-engineered search algorithms. | [Paper](https://arxiv.org/abs/2605.15871), [Tweet](https://x.com/omarsar0/status/2056434731508703607) |
| 5) **Weak-Model Critic-Comparator** - GPT-5.4 nano wrapped in a critic-comparator orchestration loop reaches 76.4% on SWE-bench Verified, matching standalone Gemini 3 Pro and Claude Opus 4.5 Thinking. The trick is to sample k=8 candidate patches from the weak model and select the winner using execution and proof signals rather than asking the model to self-rank. <br>● k=8 candidates plus verifier beats frontier model: A weak model's top-k often already contains a correct patch. The selector is the limiting factor, not the base model's capability.  <br>● Execution and proof signals as selection: Candidates are run and verified rather than scored by an LLM judge. The critic and comparator are separate roles inside the loop, each with a narrow task.  <br>● Matches frontier performance at lower per-call cost: Selecting among nano-tier proposals is cheaper than calling a frontier model once, even after accounting for the 8x sampling, because the dominant cost driver is model size rather than call count.  <br>● Why it matters: This is a reproducible recipe for getting frontier-level coding-agent results out of cheaper models. The result also reframes where SWE-bench progress is coming from: orchestration quality, not just stronger base models. | [Paper](https://arxiv.org/abs/2605.14163), [Tweet](https://x.com/dair_ai/status/2056427128401641908) |
| 6) **MetaCogAgent** - MetaCogAgent equips a multi-agent system with metacognition, so each agent decides whether it should answer or delegate. The bottleneck in current multi-agent systems is over-delegation and under-delegation, and a metacognitive gate is a principled way to manage both. The Metacognitive Unit (MCU) at each agent produces confidence scores that drive routing to a delegation hub. <br>● Confidence-driven routing: Each agent's MCU combines verbalized and profile-based confidence into a single score. Low-confidence tasks route to a delegation hub rather than getting answered anyway.  <br>● Self-aware specialization beats fixed routers: MetaCogAgent reaches 82.4% on MetaCog-Eval, versus 70.2% for a skill-fixed router and 65.3% for single-agent. Self-assessment and adaptive delegation each contribute material gains in ablations.  <br>● Emergent specialization: Distinct confidence profiles (high on coding, low on retrieval, etc.) emerge purely from feedback. No specialization is encoded beyond initial system prompts.  <br>● Why it matters: Multi-agent systems usually rely on fixed routers or simple round-robin schemes. A learned, uncertainty-aware delegation gate gives a primitive that adapts to task difficulty without retraining the routing layer. | [Paper](https://arxiv.org/abs/2605.17292), [Tweet](https://x.com/dair_ai/status/2056822215619035156) |
| 7) **Production Agent Architecture Methodology** - A methodology paper on selecting and composing runtime architecture patterns for production LLM agents. The core argument is that most teams accidentally let framework defaults make critical architecture decisions for them. The paper introduces the stochastic-deterministic boundary (SDB) as a named primitive and presents a six-pattern catalog organized by the three runtime concerns of coordination, state, and control. <br>● Stochastic-deterministic boundary: A four-part contract of proposer, verifier, commit, and reject that marks where the LLM hands off to deterministic infrastructure. The paper inventories how five widely used open-source agent frameworks place this boundary, often implicitly.  <br>● Three-by-six pattern catalog: Six patterns organized along three orthogonal concerns. Coordination patterns answer how work splits and combines. State patterns answer how the system remembers. Control patterns answer who decides what runs and when to stop.  <br>● Patterns as deliberate choices: Each pattern has a typed-contract specification of input type, output type, deadline, retry budget, and partial-result policy. The catalog grows by passing this procedure rather than by adding ad-hoc abstractions.  <br>● Why it matters: Production agent failures rarely come from the LLM. They come from architectural choices that were made by default. The methodology gives teams a way to surface those choices and make them deliberately. | [Paper](https://arxiv.org/abs/2605.20173), [Tweet](https://x.com/dair_ai/status/2057159497282707875) |
| 8) **NanoGPT-Bench** - A new evaluation of whether coding agents can do real AI R&D. Intology runs Codex, Claude Code, and Autoresearch on the NanoGPT-Bench suite and reports that the agents recover only 9.3% of human progress on the same problems. Coding agents spend the bulk of their compute on hyperparameter tuning and rarely attempt algorithmic research. Claude Code and Autoresearch reason about algorithmic changes more often, but still tend to dodge implementing them. The headline result tempers the current wave of "self-improving agent" claims: producing real research progress requires a different distribution of effort than the one current coding agents converge to under their default scaffolds. | [Paper](https://www.intology.ai/blog/nanogpt-bench), [Tweet](https://x.com/omarsar0/status/2056901737055752633) |
| 9) **General-Agent** - Prime Intellect's General-Agent is a fully synthetic reinforcement learning environment whose task corpus self-evolves and grows harder over time. The release ships with 4,504 tool-use tasks across 1,040 domains and 8,159 unique tools. Synthetic task creation is formulated as a two-player game between a Synthesizer that proposes new task families and a Solver that runs rollouts to measure pass rates. Tasks whose pass rate falls inside a calibrated difficulty band are accepted into the corpus, and hard tiers seed the next round of extensions. The framing turns RL environment creation, historically a major bottleneck, into an automated agentic search problem in its own right. | [Paper](https://www.primeintellect.ai/blog/general-agent), [Tweet](https://x.com/PrimeIntellect/status/2056569877167808966) |
| 10) **Contrastive Neuron Attribution** - Nous Research releases Contrastive Neuron Attribution (CNA), a method for steering LLM behavior by identifying and ablating sparse circuits in the MLP basis without training a sparse autoencoder, modifying weights, or degrading general capability benchmarks. Given a small set of contrastive prompt pairs that elicit a target behavior and its opposite, CNA isolates the top 0.1% of MLP neurons whose activations differ most between the two sets. Ablating that small circuit removes the behavior while leaving the rest of the model intact. The intervention remains robust at high strengths where residual-stream methods like Contrastive Activation Addition (CAA) start to degrade. Validated on the refusal circuit across 8 instruct-tuned models including Llama-3.1-70B, Llama-3.2-3B, Qwen2.5-72B, and Qwen2.5-14B. | [Paper](https://arxiv.org/abs/2605.12290), [Tweet](https://x.com/NousResearch/status/2056778746716107193) |

---

## Top AI Papers of the Week (May 11 - May 17) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **Lighthouse Attention** - Nous Research proposes a training-only attention wrapper for long-context pretraining. Lighthouse Attention wraps standard SDPA with a hierarchical, gradient-free selection layer that compresses and decompresses queries, keys, and values symmetrically while preserving left-to-right causality. The wrapper is removed near the end of training in a short recovery phase, so the deployed model runs vanilla attention with no architectural change at inference. Preliminary LLM experiments report faster total training time and lower final loss than full-attention baselines. <br>● Subquadratic wrapper with vanilla deployment: The hierarchical selector reduces the cost of long-context training without modifying the underlying attention operator. After the recovery phase, the trained weights are compatible with standard SDPA at inference.  <br>● Symmetric compression preserves causality: Queries, keys, and values are compressed and decompressed through the same hierarchy, which keeps the wrapper compatible with left-to-right attention.  <br>● Training-time speedup at lower final loss: Preliminary runs report faster wall-clock training and lower final loss than full-attention baselines under matched FLOPs, including 21x faster forward latency at 512K context.  <br>● Why it matters: A training-only modification that leaves the deployed model unchanged sidesteps the usual deployment-time tradeoffs of efficient-attention methods. | [Paper](https://arxiv.org/abs/2605.06554), [Tweet](https://x.com/omarsar0/status/2054224130103554359) |
| 2) **Is Grep All You Need?** - The paper evaluates grep-style text search against embedding-based retrieval inside coding agents. When wrapped in a suitable agent harness, grep matches or exceeds embedding retrieval on coding-agent tasks. The study isolates the contribution of the harness from the contribution of the retrieval primitive, and finds that harness design accounts for most of the performance differential typically attributed to embeddings. <br>● Direct comparison of grep vs. embeddings: Coding-agent tasks evaluated under controlled conditions show grep-based retrieval reaching parity with or exceeding embedding-based retrieval.  <br>● Harness design as the dominant variable: Holding the index constant and varying the harness produces larger performance shifts than the inverse, indicating that retrieval comparisons in prior work have likely been confounded by harness differences.  <br>● Implications for codebase structure: Grep performs best when the codebase is properly indexed and structured for an agent to navigate, while embedding retrieval can partially compensate for unstructured input.  <br>● Why it matters: Vector databases are a common default in coding-agent stacks. The result suggests that for many coding tasks, harness improvements and basic text search can substitute for embedding infrastructure. | [Paper](https://arxiv.org/abs/2605.15184), [Tweet](https://x.com/omarsar0/status/2055317577031975269) |
| 3) **A Geometric Calculator Inside a Neural Network** - Goodfire reports mechanistic interpretability work identifying a geometric calculator inside an LLM. The model represents numbers as Fourier features, where circles in activation space correspond to numbers modulo a given base. Arithmetic operations are implemented as rotations of these circles, forming a variant of a residue number system that does not require coprime moduli. The same circuit appears to be reused beyond arithmetic. <br>● Numbers as rotating circles: Numerical quantities are encoded as positions on circles in activation space, with addition implemented as rotation. The encoding extends prior findings that LLMs represent numbers via Fourier features.  <br>● Residue-system-like structure: The set of circles forms a residue number system variant. Unlike the textbook residue system, the moduli do not need to be coprime, which is the mechanistic detail the paper introduces.  <br>● Reuse beyond arithmetic: The same rotational machinery shows up in non-math contexts inside the model, suggesting the geometric calculator is a general-purpose internal structure rather than a math-specific subnetwork.  <br>● Why it matters: The finding gives interpretability researchers a concrete, reproducible circuit to target and connects geometric representation analysis to functional behavior beyond toy settings. | [Paper](https://www.goodfire.ai/research/a-geometric-calculator), [Tweet](https://x.com/GoodfireAI/status/2054962242022777189) |
| 4) **δ-mem** - δ-mem augments a frozen full-attention model with a compact online associative-memory state. The state is a fixed-size matrix updated by delta-rule learning during generation, and its readout produces low-rank corrections to the backbone's attention output. There is no fine-tuning, no backbone swap, and no context extension. <br>● Frozen backbone: The base model weights are unchanged. δ-mem adds a small online state plus a pair of low-rank read and write projections.  <br>● Delta-rule update integrated into attention: The memory matrix is updated by delta-rule learning during generation, and the readout produces additive query and output corrections to the attention computation rather than functioning as a separate retrieval step.  <br>● Results from an 8x8 state: An 8x8 online memory lifts the frozen backbone's average score by 1.10x and beats the strongest non-δ-mem memory baseline by 1.15x. On memory-heavy benchmarks the gap widens: 1.31x on MemoryAgentBench and 1.20x on LoCoMo. General capabilities are largely preserved.  <br>● Why it matters: The mechanism offers an alternative to context extension and external retrieval for long-horizon memory, with minimal deployment overhead on frozen frontier models. | [Paper](https://arxiv.org/abs/2605.12357), [Tweet](https://x.com/dair_ai/status/2054600147020222630) |
| 5) **Beyond Individual Intelligence** - A multi-agent systems survey covering 200+ papers, organized along three axes: collaboration mechanisms, failure attribution, and self-evolution. Each axis is treated as a distinct research line. The self-evolution chapter maps how memory, meta-learning, and procedure-editing approaches intersect. <br>● Three orthogonal axes: Collaboration mechanisms cover who communicates with whom and how. Failure attribution covers methods for localizing errors across agents. Self-evolution covers how a system updates its own behavior over time.  <br>● Failure attribution as a first-class topic: Errors propagate through coordination protocols in multi-agent systems, making attribution difficult. The survey treats attribution methodology as a research area rather than a debugging activity.  <br>● Self-evolution as a field map: The chapter identifies overlap between memory work, meta-learning, and procedure-editing approaches, and surfaces open questions in each area.  <br>● Why it matters: The taxonomy provides a vocabulary for comparing multi-agent systems along axes that prior work has often conflated. | [Paper](https://arxiv.org/abs/2605.14892), [Tweet](https://x.com/dair_ai/status/2055318564127809571) |
| 6) **AutoTTS** - AutoTTS reframes test-time scaling as a search problem. Instead of designing branching, pruning, and stopping heuristics directly, the user constructs a discovery environment in which TTS strategies are searched automatically. Width-depth TTS is recast as controller synthesis over pre-collected reasoning trajectories and probe signals, so candidate controllers can be evaluated without repeated LLM calls. <br>● Discovery environment plus offline evaluator: The human specifies states, actions, and feedback. An explorer LLM iteratively proposes candidate controllers. Controllers are evaluated against pre-collected trajectories rather than by re-sampling the base model.  <br>● Beta parameterization and trace-level feedback: Beta parameterization makes the controller space tractable for search. Execution-trace feedback gives the explorer information about why a candidate failed, not only that it did.  <br>● Results on math reasoning benchmarks: Discovered controllers outperform hand-designed TTS recipes on the accuracy-cost Pareto frontier and transfer zero-shot to held-out benchmarks and model scales. Total discovery cost: $39.9 and 160 minutes.  <br>● Why it matters: Automated search over TTS strategies is competitive with hand-tuned heuristics at low cost, which shifts where the research effort needs to go. | [Paper](https://arxiv.org/abs/2605.08083), [Tweet](https://x.com/omarsar0/status/2053978221193130434) |
| 7) **AI Co-Mathematician** - Google DeepMind presents AI Co-Mathematician, an agentic research workbench for mathematicians. The system is an asynchronous, stateful environment that supports ideation, literature discovery, computational analysis, theorem verification, and knowledge development across long sessions. It reaches 48% on FrontierMath Tier 4, a new high among AI systems evaluated. <br>● Asynchronous stateful workbench: The system runs as a persistent environment with multiple workstreams a mathematician can drive in parallel. Long-running computations, literature searches, and verification steps run in the background.  <br>● Manages uncertainty and intent: The workbench records unsuccessful attempts, clarifies user intent when underspecified, and emits formal mathematical outputs that can be checked rather than only read.  <br>● 48% on FrontierMath Tier 4: A new high score on the hardest tier of FrontierMath among AI systems evaluated. Early applications produced solved open problems, fresh research directions, and recovered overlooked citations during active research sessions.  <br>● Why it matters: The workbench design pattern (asynchronous, stateful, multi-workstream) generalizes to expert workflows where sessions span days rather than minutes. | [Paper](https://arxiv.org/abs/2605.06651), [Tweet](https://x.com/dair_ai/status/2054224343551639958) |
| 8) **AEvo** - AEvo separates the iterative self-improvement loop into two roles: a candidate-proposer that generates the next attempt, and a meta-agent that observes traces and edits the procedure used to propose future candidates. Past runs (candidates, feedback, traces, failures) function as memory the meta-agent reads from when revising the procedure. AEvo reports a 26% relative gain over the strongest evolution baseline on agentic and reasoning benchmarks, and SOTA on three open-ended optimization tasks under the same iteration budget. The work demonstrates one way to operationalize accumulated agentic search logs as input to procedure-level updates rather than discarding them after each run. | [Paper](https://arxiv.org/abs/2605.13821), [Tweet](https://x.com/dair_ai/status/2055000283605004602) |
| 9) **The Memory Curse in LLM Agents** - A study of how long histories affect LLM agent behavior. Across 7 LLMs and 4 social dilemma games over 500 rounds, expanding accessible history degraded cooperation in 18 of 28 model-game combinations. Lexical analysis of 378,000 reasoning traces shows the mechanism is erosion of forward-looking intent rather than increased suspicion: long histories pull the model toward reasoning about past interactions rather than future payoffs. A LoRA adapter trained only on forward-looking traces mitigates the decay and transfers zero-shot to new games. Memory sanitization, which keeps prompt length fixed but swaps in synthetic cooperative records, restores cooperation, indicating the trigger is content rather than length. Ablating explicit chain-of-thought often reduces the collapse, suggesting deliberation amplifies the effect. The paper provides a diagnostic plus interventions for long-running agent systems where history quality, not just history length, drives behavior. | [Paper](https://arxiv.org/abs/2605.08060), [Tweet](https://x.com/omarsar0/status/2053863994499408214) |
| 10) **Token Superposition Training** - Nous Research's second pretraining paper of the week. Token Superposition Training (TST) is a modification to the standard LLM pretraining loop that produces a 2 to 3x wall-clock speedup at matched FLOPs without changing the model architecture, optimizer, tokenizer, or training data. During the first third of training, the model reads and predicts contiguous bags of tokens, averaging their embeddings on the input side and predicting the next bag with a modified cross-entropy on the output side. For the remainder of the run, training reverts to standard next-token prediction. The inference-time model is identical to one produced by conventional pretraining. TST was validated at 270M, 600M, and 3B dense scales, and at a 10B-A1B mixture-of-experts model where it reaches a lower final loss while consuming 4,768 B200-GPU-hours versus the baseline's 12,311. Together with Lighthouse Attention, this is the second pretraining-loop modification from the same lab this week reporting substantial speedups without architecture changes. | [Paper](https://arxiv.org/abs/2605.06546), [Tweet](https://x.com/NousResearch/status/2054610062836892054) |

---

## Top AI Papers of the Week (May 4 - May 10) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **HeavySkill** - One of the cleaner takes on agentic harness design released this year. The paper argues that what actually drives harness performance is not the orchestration code, but a single inner skill: parallel reasoning followed by deliberation. Internalize that pattern into the model and most of the surrounding scaffolding becomes optional. HeavySkill systematizes the idea as a two-stage pipeline you can run beneath any harness, then trains it as a learnable skill via RLVR. The result is a harness win that looks more like a model win. <br>● Two-stage skill, not orchestration glue: Stage one runs parallel reasoning across multiple sampled chains. Stage two performs a deliberation pass that compares, critiques, and synthesizes those chains into a final answer. The pipeline is the same regardless of harness, which is why it transfers across tasks.  <br>● GPT-OSS-20B jumps from 69.7% to 85.5% on LiveCodeBench: Under the heavy-thinking variant (HM@4), the 20B model gets a 15.8 point lift on a hard coding benchmark. The same recipe takes R1-Distill-Qwen-32B from 35.7% to 69.3% on IFEval, nearly doubling its instruction-following score.  <br>● Pass@N-level performance from a learned skill: Several models reach Pass@N-level performance once HeavySkill is internalized through RLVR, which is the property that makes the parallel-deliberation pattern actually portable. The skill survives outside the harness it was trained under.  <br>● Why it matters: Harness wins start to look like model wins once you can train them in. If parallel reasoning plus deliberation really is the inner skill, the long arc is models that ship with it baked in, not orchestration glue layered around them. | [Paper](https://arxiv.org/abs/2605.02396), [Tweet](https://x.com/omarsar0/status/2051678102934454330) |
| 2) **Conductor** - Sakana AI's ICLR 2026 paper introduces a 7B Conductor model that hits SOTA on GPQA-Diamond and LiveCodeBench by orchestrating other LLMs instead of solving problems itself. The Conductor is trained with RL to do two things simultaneously: design communication topologies between worker agents (open or closed source) and prompt-engineer focused instructions to each worker so it leverages individual strengths. The orchestrator becomes a learnable policy, not a wrapper around one. <br>● Topology design plus targeted prompting: A single RL policy decides who talks to whom and what each worker is told. Trained against randomized agent pools, the Conductor adapts to arbitrary mixes of agents at inference time, including agents it never saw during training.  <br>● Recursive topologies emerge: When allowed to pick itself as a worker, the Conductor forms recursive topologies, unlocking a new form of dynamic test-time scaling through online iterative adaptation. Coordination becomes its own scaling axis, separate from model size or context length.  <br>● 3% gains on AIME25 and GPQA-D from coordination alone: The gains over the best individual worker land in the 3% range, which the authors note is consistent with entire generational improvements between frontier model versions. The difference is that here the lift comes from learned routing, not from larger pretraining runs.  <br>● Why it matters: This is one of the cleaner arguments yet that the orchestrator should be the model. Routing decisions stop being a wrapper and become a learnable policy, which is the right abstraction for production agent stacks that compose multiple model providers. | [Paper](https://arxiv.org/abs/2512.04388), [Tweet](https://x.com/omarsar0/status/2051306659021242635) |
| 3) **Self-Improving Pretraining** - Most LLM safety, factuality, and reasoning fixes get bolted on at post-training. By then the patterns have already set. This Meta FAIR paper moves those behaviors into pretraining itself. The team uses a strong post-trained model as both a rewriter and a judge: it rewrites pretraining suffixes toward higher-quality, safer continuations, then scores model rollouts against the original suffix and the rewrite to drive RL during pretraining. Instead of next-token prediction, the policy learns sequence generation from the start, with rewards for quality, safety, and factuality. <br>● Post-trained model as rewriter and judge: The strong model rewrites suffixes during pretraining, then judges rollouts of the in-training model against both the rewrite and the original. Safety, factuality, and quality become reward signals rather than post-hoc filters, which lets the policy internalize the targets early.  <br>● Sequence generation from the start: The policy is trained to generate sequences directly under reward, not to predict the next token. This shifts the inductive bias toward producing the kinds of continuations the judge rewards, which matters most on long-form generation where token-level losses lose discriminative signal.  <br>● Concrete gains across the board: 36.2% relative gain in factuality, 18.5% in safety, and up to 86.3% win rate in generation quality over standard pretraining. The safety and factuality numbers are large enough to suggest these properties are easier to install during pretraining than to retrofit after the fact.  <br>● Why it matters: The post-trained models you already have can be used to pretrain the next ones better. That is a recursive improvement loop at the pretraining layer, which is where the largest behavioral commitments actually get locked in. | [Paper](https://arxiv.org/abs/2601.21343), [Tweet](https://x.com/omarsar0/status/2050213732970848664) |
| 4) **Connect Four AlphaZero from Scratch** - This paper proposes a new way to evaluate coding agents: hand them a minimal task description, give them a tight budget, and ask them to autonomously rebuild a famous ML breakthrough end-to-end. Connect Four plus AlphaZero is the first instance. It is small enough to run on a laptop and hard enough to require a real research engineering loop. Claude Opus 4.7 implemented the full pipeline (MCTS, neural value and policy nets, self-play, training schedule) in three hours on consumer hardware, then beat the Pascal Pons solver 7 of 8 as first-mover. No other frontier coding agent tested cleared 2 of 8. <br>● From patches to systems: Existing coding-agent benchmarks measure unit-test fixes and small patches. This benchmark measures whether the agent can build a non-trivial ML system from a one-paragraph spec, which is closer to what production research engineering actually looks like.  <br>● Tight budget, real research loop: The agent has to design the search algorithm, train the networks, schedule self-play, and debug the loop, all within a fixed compute budget on consumer hardware. There is no escape hatch into a pre-built library, which is what makes the task discriminative.  <br>● A clean separation between frontier coders: Claude Opus 4.7 reached 7 of 8 wins as first-mover against the Pascal Pons solver. No other frontier coding agent tested cleared 2 of 8. The gap is large enough to suggest the benchmark is detecting something real about end-to-end ML engineering capability.  <br>● Why it matters: Patch-style benchmarks are starting to saturate. Rebuild-a-breakthrough tasks give the field a harder ceiling to push against, and they map more directly to the agent workloads people actually want to deploy. | [Paper](https://arxiv.org/abs/2604.25067), [Tweet](https://x.com/omarsar0/status/2050693576250753233) |
| 5) **Coordination as Architecture** - Multi-agent LLM systems fail in production at rates between 41% and 87%, and the majority of those failures are coordination defects, not base-model capability. Most published comparisons of multi-agent architectures cannot even tell you whether the gain came from coordination or from one configuration just having more context. This paper argues coordination should be treated as a configurable architectural layer, separable from agent logic and information access, then backs the position with an information-controlled experiment. <br>● Information-controlled methodology: Same LLM, same tools, same prompt template, same per-call output cap. The only thing that varies is coordination structure. Once information access is held constant, the actual contribution of coordination becomes measurable for the first time.  <br>● Coordination as a separate layer: The paper proposes treating coordination structure (who talks to whom, when, with what aggregation rule) as a first-class architectural axis. That separation lets teams reason about coordination changes without re-running the entire stack.  <br>● A vocabulary for the field: Until now, "multi-agent beats single-agent" comparisons have been confounded by context-window asymmetries. This paper provides the methodology and vocabulary needed to actually test coordination claims, which is overdue infrastructure for the multi-agent research line.  <br>● Why it matters: If 41% to 87% of failures are coordination defects, fixing coordination is the highest-leverage thing builders can do. The paper turns that intuition into a measurable engineering target instead of a vibes-based debate. | [Paper](https://arxiv.org/abs/2605.03310), [Tweet](https://x.com/dair_ai/status/2052429021833818458) |
| 6) **Horizon Generalization** - Microsoft Research runs a controlled study where the only variable is task horizon length. Same decision rules, same reasoning structure, different sequence length to the goal. The main finding: horizon alone is a training bottleneck. As goal distance grows, exploration explodes combinatorially and credit assignment gets ambiguous. Models that learn cleanly on short horizons fall apart on long ones, even when the underlying reasoning is identical. The fix is not more compute, it is horizon reduction. <br>● Horizon as a first-class variable: By holding decision rules and reasoning constant and only varying sequence length, the paper isolates horizon as a distinct training bottleneck. This separates "the agent cannot reason" from "the agent cannot stitch together long sequences," which most prior work conflated.  <br>● Macro actions stabilize training: Re-parameterizing the action space with macro actions that compress many low-level decisions into one stabilizes training immediately. The agent learns the same task, just at a coarser temporal grain that keeps credit assignment tractable.  <br>● Generalization to longer horizons at inference: Models trained on reduced horizons generalize to longer ones at inference time. The paper calls this horizon generalization, and it is the most useful property because it means you can train cheap and deploy long.  <br>● Why it matters: Most teams treat long-horizon failures as a model-capacity problem. This paper says it is a horizon problem. Reduce horizon during training, get stability now and generalization for free at inference, without retraining a larger backbone. | [Paper](https://arxiv.org/abs/2605.02572), [Tweet](https://x.com/dair_ai/status/2051679862788878354) |
| 7) **1,000 Synthetic Computers** - Microsoft Research builds 1,000 synthetic computers, each with realistic directory structures, documents, and artifacts, then runs long-horizon simulations on top of them. One agent plays the user and sets productivity goals; another executes the work. Each simulation runs over 8 hours of agent runtime and 2,000+ turns on average, roughly a month of human work compressed into one trace. Training on this experiential data drives significant improvements on both in-domain and out-of-domain productivity evaluations. <br>● Realistic synthetic environments: Each of the 1,000 computers ships with directory structures, documents, and artifacts that approximate a real user's working environment. The realism is what makes the trajectories useful as training data instead of as evaluation curiosities.  <br>● Two-agent simulation loop: A user agent sets productivity goals while a worker agent executes against them. The structure produces multi-turn, goal-directed traces that look like real productivity work, not the short scripted tasks that dominate existing benchmarks.  <br>● Designed to scale to billions of worlds: The framework is explicitly designed to scale to millions or billions of synthetic user worlds, which matches the scale at which frontier computer-use agents will need experiential data. The bottleneck on long-horizon training is data, and this is a credible recipe for producing it.  <br>● Why it matters: The bottleneck on computer-use agents has stopped being model capability and become realistic long-horizon training data. Synthetic-environment scaling is one of the few paths that does not depend on collecting massive amounts of real user telemetry, which makes it a practical default for teams building computer-use stacks. | [Paper](https://arxiv.org/abs/2604.28181), [Tweet](https://x.com/dair_ai/status/2050263752147456238) |
| 8) **Contextual Agentic Memory is a Memo** - Most agent memory today is not memory, it is closer to a memo. Vector stores, RAG buffers, and scratchpads implement lookup, not consolidation. The paper draws on neuroscience's Complementary Learning Systems theory: biological intelligence pairs fast hippocampal storage with slow neocortical consolidation, and current AI agents only implement the first half (fast write, similarity recall, no abstraction step). The authors prove a generalization ceiling on compositionally novel tasks: as long as memory stays retrieval-only, the agent cannot apply abstract rules to inputs that do not already look like something in the store, and it remains permanently exposed to memory poisoning. If you are building long-running agents and treating memory as a vector index, this paper is a clean diagnosis of what you are missing. | [Paper](https://arxiv.org/abs/2604.27707), [Tweet](https://x.com/dair_ai/status/2050694339165335754) |
| 9) **Agentic-imodels** - The entire interpretability literature is built around human readers. As more analysis gets delegated to agents, the right target of interpretability shifts. Microsoft Research introduces Agentic-imodels, an autoresearch loop where a coding agent (Claude Code, Codex) iteratively evolves scikit-learn-compatible regressors that are simultaneously accurate AND readable by other LLMs. Interpretability is measured by whether a small LLM can simulate the fitted model's behavior just by reading its string representation, predictions, feature effects, and counterfactuals from the __str__ output alone. Across 65 tabular datasets, the discovered models push the Pareto frontier past every classical interpretable baseline (decision trees, GAMs, sparse linear), and improve four downstream agentic data-science systems on the BLADE benchmark by 8% to 73%. | [Paper](https://arxiv.org/abs/2605.03808), [Tweet](https://x.com/dair_ai/status/2052125514266190286) |
| 10) **Skills as Verifiable Artifacts** - If you ship agent skills, your runtime is treating signed-and-cleared skills as trusted by default. This paper argues a skill is untrusted code until it is verified, and the runtime should enforce that default rather than infer trust from origin. Without skill verification, HITL has to fire on every irreversible call, which degrades into rubber-stamping at any non-trivial scale. With verification as a separate gated process, HITL fires only for what is unverified. Skills are now first-class deployment artifacts, and we have decades of supply-chain lessons on what happens when trust is inferred from a signature. This is the right ask for SKILL.md before agent skill libraries become the next attack surface. | [Paper](https://arxiv.org/abs/2605.00424), [Tweet](https://x.com/omarsar0/status/2051772437520622035) |

---

## Top AI Papers of the Week (April 26 - May 3) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **Agentic Harness Engineering** - Most coding-agent harnesses are still tuned by hand or kept alive through brittle trial-and-error self-evolution. This paper introduces Agentic Harness Engineering (AHE), a framework that makes harness evolution observable and falsifiable. AHE separates the system into three layers: components stored as revertible files, experience condensed from millions of trajectory tokens into structured evidence, and decisions written as predictions that get checked against task outcomes. Every edit becomes a contract you can verify or revert. <br>● Three-layer evolution model: Components, experience, and decisions are each first-class artifacts. Components are versioned files, experience is compressed evidence pulled from full trajectory logs, and decisions are explicit hypotheses with expected outcomes. The structure turns black-box harness tuning into an auditable engineering loop.  <br>● Pass@1 gains on Terminal-Bench 2: Pass@1 climbs from 69.7% to 77.0% across ten iterations, beating both human-designed Codex-CLI (71.9%) and self-evolving baselines like ACE and TF-GRPO. The framework also uses 12% fewer tokens than the seed harness on SWE-bench-verified.  <br>● Cross-model transfer: The evolved harness transfers across model families with +5.1 to +10.1 point gains, suggesting the optimizations are structural rather than overfit to a specific backbone. That is the property you actually want from harness engineering.  <br>● Why it matters: Harness work is the largest hidden cost in most agent systems. AHE is the first credible recipe for letting the harness improve itself without drifting into noise, which makes it the most important agent-systems paper of the week. | [Paper](https://arxiv.org/abs/2604.25850), [Tweet](https://x.com/omarsar0/status/2049492169887748365) |
| 2) **AgenticQwen-30B-A3B** - Alibaba shows that a 30B MoE model with only 3B active parameters can match Qwen3-235B on real tool-use workloads. AgenticQwen-30B-A3B scores 50.2 average on TAU-2 plus BFCL-V4 Multi-Turn, while AgenticQwen-8B scores 47.4. Both more than double their vanilla Qwen baselines and close most of the gap to a 235B model. The recipe is built around two reinforcement learning flywheels that run in parallel, with simulated users actively trying to mislead the agent. <br>● Reasoning flywheel from self-failure: The first loop mines the model's own errors and converts them into harder reasoning problems each round. The training distribution gets harder on its own as the model improves, removing the need for new human-curated reasoning data.  <br>● Agentic flywheel for tool use: The second loop grows simple linear tool-use trajectories into multi-branch behavior trees. Simulated users test recovery from misleading instructions, ambiguous goals, and failed tool calls, which is where vanilla supervised tuning typically breaks.  <br>● Real efficiency for production agents: A 30B MoE with 3B active tokens at inference is significantly cheaper to serve than a 235B dense or MoE alternative. For tool-use workloads where frontier reasoning is overkill, this changes the cost profile of shipping production agents.  <br>● A reusable recipe: The flywheel approach generalizes beyond Qwen. Teams can generate hard examples from their own agent's failures rather than relying on static synthetic data, which is the more scalable path for domain-specific agents. | [Paper](https://arxiv.org/abs/2604.21590), [Tweet](https://x.com/omarsar0/status/2048504655932760565) |
| 3) **Agentic World Modeling** - A massive 40-author survey lands the cleanest taxonomy of world models in agent research released so far. The paper proposes a "levels by laws" framework spanning three capability levels and four law regimes, then synthesizes 400+ works and 100+ representative systems across model-based RL, video generation, web and GUI agents, multi-agent simulation, and scientific discovery. As agents shift from chatbots to goal-accomplishers, the bottleneck moves from language to environment, and this is the first paper that gives builders a shared vocabulary across communities that have been working in isolation. <br>● Three capability levels: L1 Predictors handle one-step transitions, L2 Simulators do multi-step action-conditioned rollouts, and L3 Evolvers self-revise as the world changes. The hierarchy makes it easy to place existing systems and identify where capability gaps actually live.  <br>● Four law regimes: Physical, digital, social, and scientific laws each impose different constraints on what a world model needs to capture. The framework treats them as orthogonal axes, which clarifies why a strong physics simulator can still fail at social or digital tasks.  <br>● Failure-mode catalog: The survey extracts recurring failure patterns across 100+ systems, including misaligned reward shaping, drift under non-stationarity, and brittle transfer across regimes. Each failure mode is mapped to a level and law combination, so the diagnosis is grounded.  <br>● Evaluation principles per level: The authors propose evaluation criteria specific to each capability level rather than a single benchmark. This is the right move because L1 prediction accuracy and L3 self-revision quality are not measurable on the same axis. | [Paper](https://arxiv.org/abs/2604.22748), [Tweet](https://x.com/omarsar0/status/2048783073547079816) |
| 4) **RecursiveMAS** - Multi-agent systems usually pass full text messages between agents at every step, which causes token bloat, latency, and context dilution that all grow with team size. RecursiveMAS asks a different question: what if agents collaborated through recursive computation in a shared latent space instead of through text? The system treats a multi-agent team as a recursive computation where each agent acts like an RLM layer, iteratively passing latent representations to the next and forming a looped interaction process. Less talking, more thinking. <br>● RecursiveLink for latent communication: A RecursiveLink module generates latent thoughts and transfers state directly between heterogeneous agents, replacing natural-language messages with internal representations. The change removes the cost of re-encoding and re-parsing text on every coordination step.  <br>● Inner-outer loop learning: The training algorithm uses an inner loop for per-step latent updates and an outer loop for team-level credit assignment, with shared gradient-based updates across agents. This makes joint optimization tractable instead of relying on hand-tuned communication protocols.  <br>● Strong gains across 9 benchmarks: Across math, science, medicine, search, and code generation, RecursiveMAS delivers 8.3% average accuracy gain over baselines, 1.2x to 2.4x end-to-end inference speedup, and 34.6% to 75.6% reduction in token usage. The efficiency story is at least as important as the accuracy story.  <br>● A path past the agent communication tax: If agent-to-agent communication is the next real bottleneck, latent-space recursion is one of the cleaner ways to scale collaboration. Teams running multi-agent systems at scale should treat this as a serious design alternative, not a research curiosity. | [Paper](https://arxiv.org/abs/2604.25917), [Tweet](https://x.com/omarsar0/status/2050261229315477988) |
| 5) **OneManCompany** - If you are building multi-agent systems, you are probably wiring static org charts. This paper argues they should look more like a labor market. OneManCompany (OMC) replaces fixed teams with "Talents," portable agent identities that bundle skills and tools, and a "Talent Market" where agents get recruited dynamically per task. An Explore-Execute-Review tree search decomposes work hierarchically and aggregates results back up. On PRDBench, OMC reaches 84.67% success, +15.5 points over prior SOTA, and the framework generalizes across the case studies the authors run. <br>● Talents as portable identities: A Talent bundles a skill set, tool access, and behavioral priors into a reusable agent identity. Talents can be hired into any task without rewiring the orchestration graph, which removes most of the brittleness in pre-wired multi-agent pipelines.  <br>● Dynamic recruitment via Talent Market: Tasks post requirements, and the market matches Talents to roles based on capability fit and current load. This replaces the standard "design a team for every workflow" pattern with on-demand assembly that adapts as the task population shifts.  <br>● Explore-Execute-Review tree search: Work is decomposed top-down into subtasks, executed in parallel by recruited Talents, then reviewed and aggregated up the tree. The structure naturally supports retries, branching, and cross-checking without manual coordination logic.  <br>● Why it matters: Pre-wired multi-agent pipelines break the moment tasks drift outside their design envelope. Treating agents as a recruitable workforce gets you self-organization and continuous improvement by default, which is what open-ended agent systems need. | [Paper](https://arxiv.org/abs/2604.22446), [Tweet](https://x.com/dair_ai/status/2048909068409147460) |
| 6) **From Skill Text to Skill Structure** - SKILL.md files entangle invocation interface, execution flow, and tool side effects in a single blob of natural language. That makes downstream discovery and risk review brittle as skill registries scale. This paper proposes SSL, a three-layer typed JSON representation drawn from Schank and Abelson's classical work on scripts, MOPs, and conceptual dependency. An LLM-based normalizer converts existing SKILL.md files into the structure, so adoption does not require rewriting registries by hand. <br>● Three layers, cleanly separated: A Scheduling layer captures invocation signals and trigger conditions, a Structural layer encodes execution scenes and ordering, and a Logical layer specifies atomic actions plus resource and side-effect annotations. The separation lets discovery, risk, and execution each reason about the layer they care about.  <br>● Skill Discovery MRR jumps 0.573 to 0.707: Treating skills as typed structure rather than prose makes retrieval significantly more accurate, even before any model fine-tuning. The gain comes from the structure exposing what skills actually do, not just how they describe themselves.  <br>● Risk Assessment macro F1 of 0.787: The Logical layer's resource annotations enable a 0.744 to 0.787 jump in risk classification. Auditors can now reason about side effects directly instead of inferring them from free-form prose.  <br>● A 6,184-skill corpus released: The authors ship a normalized corpus of 6,184 skills, 403 task queries, and 500 risk-labeled skills. As skill registries cross a million entries, structured representations are the only path that keeps discovery and review tractable. | [Paper](https://arxiv.org/abs/2604.24026), [Tweet](https://x.com/omarsar0/status/2049252335105491147) |
| 7) **Latent Agents** - Multi-agent debate makes models reason better. It also burns tokens generating long transcripts before any answer comes out. Latent Agents distills the entire debate into a single LLM through a two-stage fine-tuning pipeline: the model first learns debate structure, then internalizes it through dynamic reward scheduling and length clipping. The internalized model matches or beats explicit multi-agent debate while using up to 93% fewer tokens, which makes debate-quality reasoning practical at production scale. <br>● Two-stage internalization pipeline: Stage one teaches the structure of debate (turn taking, critique, revision) through supervised fine-tuning on transcript data. Stage two uses dynamic reward scheduling and length clipping to compress that structure into single-pass reasoning without losing the gains from the multi-agent setup.  <br>● Up to 93% token savings: The internalized model matches or beats explicit debate accuracy while drastically reducing inference cost. For teams running reasoning workloads at scale, this is the kind of efficiency win that turns a research idea into a deployment default.  <br>● Activation steering reveals agent subspaces: The "agents" survive distillation as identifiable circuits in activation space. Probing finds interpretable directions corresponding to different agent perspectives, which means the internal structure persists even when the external transcript is gone.  <br>● A safety angle worth noting: When malicious agents are deliberately embedded via distillation, negative steering suppresses them more cleanly than steering a base model would, with smaller hits to general performance. Internalized debate may turn out to be a useful interpretability and alignment substrate, not just a token-saver. | [Paper](https://arxiv.org/abs/2604.24881), [Tweet](https://x.com/dair_ai/status/2049493173639278818) |
| 8) **OCR-Memory** - Most agent memory systems compress trajectories into text summaries and hope the model remembers what matters, which is exactly where the information loss hides. OCR-Memory renders the agent's interaction history as images with indexed visual anchors, then retrieves via a locate-and-transcribe pipeline: the model scans visual memory, predicts the index of the relevant region, and the original text is fetched verbatim from a database. Older trajectories are stored as low-resolution thumbnails with active-recall up-sampling, and the method reaches SOTA on Mind2Web and AppWorld under strict context limits. | [Paper](https://arxiv.org/abs/2604.26622), [Tweet](https://x.com/dair_ai/status/2049957482811056307) |
| 9) **When to Retrieve During Reasoning** - Most RAG systems retrieve once, before the model starts reasoning. Large reasoning models like o1 and R1 do not work that way. They generate 12k to 25k token chains of thought and hit knowledge gaps mid-inference, long after the retrieval window closed. ReaLM-Retrieve is a reasoning-aware retrieval framework that injects evidence during multi-step inference, detects uncertainty at reasoning-step granularity, and learns a policy for when external evidence actually helps. It achieves +10.1% absolute F1 over standard RAG across MuSiQue, HotpotQA, and 2WikiMultiHopQA, with 47% fewer retrieval calls than fixed-interval IRCoT, and hits 71.2% F1 on 2-4 hop MuSiQue with only 1.8 retrieval calls per question. | [Paper](https://arxiv.org/abs/2604.26649), [Tweet](https://x.com/omarsar0/status/2049954716298494386) |
| 10) **Co-evolving Decisions and Skills** - Long-horizon agents fail in two ways: the decision-maker cannot decompose well, or the skill library goes stale. This paper introduces a co-evolution framework where an LLM decision agent and a dynamic skill bank improve each other through iterative refinement. The decision agent picks and chains skills, performance feedback updates both the policy and the skills, and new skills emerge by generalizing successful sequences instead of being hand-coded upfront. Most long-horizon agent stacks treat skills and decision-making as separate optimization problems, which is why they plateau. Co-evolution gives you adaptive planning and a growing library of reusable behaviors from a single loop, which is what you actually want when task structure is not predetermined: robotics, game agents, and complex planning. | [Paper](https://arxiv.org/abs/2604.20987), [Tweet](https://x.com/omarsar0/status/2048440985726955998) |

---

## Top AI Papers of the Week (April 19 - April 26) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **DeepSeek V4** - DeepSeek V4 is the first open model family built from the ground up around million-token contexts as a default rather than a bolt-on feature. The release includes DeepSeek-V4-Pro (1.6T total / 49B active) and DeepSeek-V4-Flash (284B total / 13B active), both trained natively at 1M context length. The tech report details a hybrid attention architecture, new training stability techniques, and a domain-specialist post-training pipeline that together push the open-source frontier much closer to GPT-5.2 and Gemini 3.0-Pro at a fraction of the cost. <br>● Hybrid attention with CSA and HCA: DeepSeek V4 replaces a single attention stack with Compressed Sparse Attention (CSA) and Heavily Compressed Attention (HCA). CSA compresses KV entries, then applies DeepSeek Sparse Attention with sliding-window KV for fine-grained local dependencies. HCA aggressively compresses KV for extreme-context layers, keeping the model feasible at 1M tokens.  <br>● Training stability at trillion-parameter scale: The team introduces two techniques that materially cut loss spikes. Anticipatory Routing decouples backbone and router updates, using current weights for features but historical weights for routing indices. SwiGLU Clamping bounds the linear and gate components of SwiGLU to stabilize activations throughout pretraining.  <br>● Domain-specialist post-training: Instead of one large mixed-RL stage, DeepSeek trains a separate specialist expert per domain. Each expert goes through supervised fine-tuning on domain data, then Group Relative Policy Optimization (GRPO) RL with a domain-specific reward model. The specialists are merged into the final model, recovering capability without destabilizing the generalist.  <br>● Frontier-adjacent performance at open-source cost: DeepSeek-V4-Pro-Max beats GPT-5.2 and Gemini 3.0-Pro on standard reasoning benchmarks and lands just behind GPT-5.4 and Gemini 3.1-Pro, effectively trailing the closed frontier by roughly 3 to 6 months. For open-weights teams that need long-context reasoning without closed API pricing, this is the most important release of the week. | [Paper](https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro/blob/main/DeepSeek_V4.pdf), [Tweet](https://x.com/deepseek_ai/status/2047516922263285776) |
| 2) **Autogenesis** - Static agents age quickly. As deployment environments change and new tools arrive, the agents that survive will be the ones that can safely rewrite themselves. This paper introduces Autogenesis, a self-evolving agent protocol where agents identify their own capability gaps, generate candidate improvements, validate them through testing, and integrate what works back into their own operational framework. No retraining and no human patching, just an ongoing loop of assessment, proposal, validation, and integration. <br>● Two-layer protocol design: Autogenesis separates a Resource Substrate Protocol Layer (RSPL) that standardizes access to prompts, tools, environments, and memory from a Self-Evolution Protocol Layer (SEPL) that runs a Generate, Reflect, Improve, Evaluate, Commit loop over evolvable variables. The split keeps core capability registration stable while evolution happens on top.  <br>● Auditable lineage and rollback: Improvements are committed with version lineage, state access control, and reversible lifecycle operations. The protocol treats every self-modification as a first-class artifact that can be inspected, reproduced, or rolled back, which is what makes self-improvement safe enough to deploy.  <br>● Multi-agent applications: Autogenesis is demonstrated on multi-agent systems with planner, executor, and analyst roles. Agents evolve their own prompts, tool wrappers, and coordination routines using the shared protocol, showing that the abstraction is general enough to hold across roles rather than being tied to a single agent type.  <br>● Part of a broader self-improvement wave: The paper sits alongside Meta-Harness and the Darwin Gödel Machine as a concrete framework for operationalizing self-modification. Together they mark a shift from "agents that use tools" to "agents that edit their own tooling." | [Paper](https://arxiv.org/abs/2604.15034), [Tweet](https://x.com/omarsar0/status/2045241905227915498) |
| 3) **Attention to Mamba** - Apple proposes a two-stage recipe for cross-architecture distillation from Transformers into Mamba. Naive distillation collapses teacher performance because a Mamba student cannot directly imitate softmax attention. The fix is to distill the transformer into a linearized-attention student using a kernel adaptation first, then transfer that student into a pure Mamba with no attention blocks. On a 1B model trained on 10B tokens, the Mamba student hits 14.11 perplexity against a 13.86 Pythia-1B teacher, nearly matching quality at linear-time inference cost. <br>● Stage 1, softmax to linear attention: The first stage replaces softmax attention with a Hedgehog-style linearized attention student, using a learnable kernel feature map that preserves the original attention scores while removing the softmax nonlinearity. This gives a strictly linear-complexity intermediate that stays close to the teacher.  <br>● Stage 2, linear attention to Mamba: The second stage transfers the linearized student into a HedgeMamba block, a hybrid SSM architecture that reuses the learned linear attention parameters and adds state-space components. The transition preserves quality because the two formulations are mathematically related, not just structurally similar.  <br>● Quality at long context: On downstream benchmarks, the distilled Mamba reaches 74.1% of the teacher's accuracy, with the recipe generalizing to 1B and 3B scales. The key practical win is retaining Transformer-level quality on the sequence mixing block while moving to linear time at inference.  <br>● A cheaper path to SSM deployment: If trained Transformers can be reliably converted into state-space models without retraining from scratch, the entire open-weights ecosystem becomes cheaper to serve at long context. This is the kind of quiet infrastructure work that matters more than it looks. | [Paper](https://arxiv.org/abs/2604.14191), [Tweet](https://x.com/dair_ai/status/2045600012860801113) |
| 4) **Skill-RAG** - Most RAG systems retrieve on every query, whether the model needs help or not. This is wasteful when the model already knows the answer and often too late when it does not. This paper introduces Skill-RAG, a failure-state-aware retrieval system that uses hidden-state probing to detect when an LLM is approaching a knowledge failure, then routes the query to a specialized retrieval strategy matched to the gap. <br>● Hidden-state probing as a retrieval trigger: Skill-RAG trains a lightweight probe on the LLM's hidden representations that predicts whether the model is about to fail the query. Only queries that clear the probe's failure threshold trigger retrieval, which cuts unnecessary search calls while preserving answers for the cases that actually need help.  <br>● Skill-matched retrieval strategies: Different failure modes (factual recall, multi-hop reasoning, temporal knowledge) are routed to different retrieval "skills" rather than a single generic retriever. Each skill is treated as a standalone component the agent can select between, echoing the broader trend of turning RAG into a collection of composable primitives.  <br>● Consistent gains across benchmarks: Evaluated on HotpotQA, Natural Questions, and TriviaQA, Skill-RAG improves over uniform RAG baselines on both efficiency and accuracy. The efficiency story matters as much as the accuracy: per-query retrieval cost drops significantly when the system skips retrieval for questions the model can already answer.  <br>● A shift in how RAG is designed: The work reinforces the direction RAG is heading: from a single monolithic pipeline to a suite of retrieval skills an agent selects between. Knowing when to retrieve and what kind of retrieval to run is becoming the central design question. | [Paper](https://arxiv.org/abs/2604.15771), [Tweet](https://x.com/omarsar0/status/2046249336162632155) |
| 5) **Self-Generated World Knowledge** - How far are we from agents that can self-generate world knowledge? This paper proposes an outcome-based reward that measures how much an agent's self-generated world knowledge actually improves its task success rate, then trains with that signal and removes the external guidance at inference. The result is a 14B model that surpasses Gemini-2.5-Flash on web navigation and gains +20% on WebVoyager and WebWalker benchmarks. <br>● Outcome-based reward for knowledge: Rather than scoring knowledge against a human-labeled reference, the reward is whether the generated knowledge measurably improves task success when the agent uses it. This lets the system learn which internally generated facts are worth keeping without an external oracle.  <br>● Multistage training pipeline: The method combines supervised fine-tuning on an instruction-and-trajectory dataset with reinforcement rejection sampling, where the best trajectories (ranked by the outcome reward) are used to update the policy. The training loop iterates between generation, reward scoring, and rejection sampling until the model internalizes effective knowledge-use behaviors.  <br>● Knowledge-enhanced execution at inference: At inference the external environment feedback loop is removed. The agent self-generates world knowledge, uses it to plan, and executes, without any human or reward signal in the loop. This is what makes the method deployable, not just measurable.  <br>● Environment design replaces labeling: If agents can reliably improve themselves by exploring the world rather than waiting for human-labeled rewards, the bottleneck for scaling agentic systems shifts from data curation to environment design. That matches the broader direction of the field and gives practitioners a concrete recipe to follow. | [Paper](https://arxiv.org/abs/2604.18131), [Tweet](https://x.com/dair_ai/status/2047061650189307953) |
| 6) **Self-Evolving Logic Synthesis** - EDA tools like ABC have been hand-tuned by humans for decades. NVIDIA shows they can evolve themselves. This work introduces the first self-evolving logic synthesis framework, a multi-agent LLM system that autonomously refines the entire ABC codebase, generates and tests candidate optimization sequences against standard benchmark circuits, then merges improvements back into the base tool. No human engineer in the loop. <br>● Multi-agent refinement of a real EDA toolchain: The framework assigns specialized agents to exploration, synthesis, and self-review tasks. Agents read and modify the ABC source directly, propose optimization flows, and run them against benchmark circuits such as EPFL, IWLS, and VTR, with three-pass human-domain knowledge injected through the pipeline.  <br>● Measured improvement over hand-tuned baselines: The evolved ABC variants produce better area, delay, and switching metrics than the hand-tuned reference on the benchmark suite, and the improvements persist under sensitivity analysis. This is a real gain on a tool the semiconductor industry depends on.  <br>● Codebase-level evolution, not just prompt tuning: The agents edit the ABC codebase itself, not just a configuration layer. That is a meaningful extension of the self-improving agent thread: the unit of improvement is real production code, not a prompt or policy.  <br>● Generalizable blueprint for domain tools: If agents can evolve a foundational semiconductor tool without manual engineering, the same pattern generalizes to any large, domain-specific codebase. It is a concrete extension of the self-improving agent thread, applied to infrastructure that shipping chips depend on. | [Paper](https://arxiv.org/abs/2604.15082), [Tweet](https://x.com/dair_ai/status/2046251813738025025) |
| 7) **Stateless Decision Memory** - Most interesting AI agent papers right now are about capability. This one is about plumbing, and it is probably more important than it looks. Stateful agents do not scale horizontally. The moment you need thousands of concurrent agent instances running across containers, persistent per-agent state becomes the bottleneck. This paper proposes replacing active memory with immutable decision logs using event-sourcing principles from distributed systems. <br>● Decision logs instead of live state: Every agent decision, tool call, and observation is appended to an immutable event log. Any instance can reconstruct context by replaying the log on demand, which decouples decision logic from storage and lets agents spin up anywhere with no warmup.  <br>● Enterprise properties by design: Compared to summary-only, SAM, and vector-memory baselines, Decision Process Memory (DPM) is the only architecture that supports append-only logging, stateless projection, audit-ready rationale trails, replay from log alone, multi-tenant isolation, and per-event provenance. Each of these is a hard requirement in regulated enterprise deployments.  <br>● Tight-budget performance wins: On FRP, RCS, and EDA evaluations under constrained memory budgets, DPM substantially outperforms summary-only memory, with the gap widening as the budget tightens. Under loose budgets the approaches converge, which is the expected pattern once scale is no longer the constraint.  <br>● A blueprint for regulated deployments: For teams operationalizing agents in finance, healthcare, or other compliance-heavy industries, the paper reads as a practical specification. It maps existing distributed-systems discipline onto agent memory instead of inventing a new category, which is why it is likely to age well. | [Paper](https://arxiv.org/abs/2604.20158), [Tweet](https://x.com/omarsar0/status/2047325132096758228) |
| 8) **There Will Be a Scientific Theory of Deep Learning** - A position paper arguing that a genuine scientific theory of deep learning is already taking shape under the umbrella of "learning mechanics." The authors identify five converging research directions (solvable idealized models, tractable mathematical limits, simple macroscopic laws, hyperparameter theories, and universal cross-system behaviors) that share a common signature: they describe training dynamics, target coarse aggregate statistics, and commit to falsifiable quantitative predictions. The framing pushes back on skepticism about whether deep learning can have fundamental theory and positions learning mechanics as a complement to mechanistic interpretability, not a competitor. | [Paper](https://arxiv.org/abs/2604.21691), [Tweet](https://x.com/learning_mech/status/2047723849874330047) |
| 9) **MASS-RAG** - Most real-world RAG failures come from retrieving technically-relevant but contextually useless documents, then forcing a single model to reconcile them. MASS-RAG is a multi-agent synthesis framework for retrieval-augmented generation where specialized agents handle distinct roles: retrieving candidate documents, assessing their actual relevance to the query, and synthesizing the final answer from evidence that actually contributes. Instead of one model doing everything, responsibility is decomposed across coordinated evaluators, which fits the direction the field is heading for deep research agents. | [Paper](https://arxiv.org/abs/2604.18509), [Tweet](https://x.com/omarsar0/status/2046594362931556728) |
| 10) **Diversity Collapse in Multi-Agent LLMs** - Every multi-agent system pitch assumes agents explore different solutions, but this paper shows they converge on near-identical outputs over time, even across different architectures and different starting prompts. The authors call it diversity collapse. The cause is structural coupling: shared context, shared task descriptions, and mutual feedback pull every agent toward the same attractor. They measure it formally with metrics like the Vendi score, and the homogenization is real. The practical consequence is that multi-agent setups for brainstorming, hypothesis generation, and ideation only work if teams explicitly engineer isolated reasoning phases, decoupled evaluation, and heterogeneous starting conditions. | [Paper](https://arxiv.org/abs/2604.18005), [Tweet](https://x.com/dair_ai/status/2047326894992081296) |

---

## Top AI Papers of the Week (April 13 - April 19) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **Automated Weak-to-Strong Researcher** - Anthropic shows that Claude can run fully autonomous progress on scalable oversight research. A team of parallel Automated Alignment Researchers (AARs) built on Claude Opus 4.6 propose ideas, run experiments, and iterate on weak-to-strong supervision, a core alignment problem where a stronger model must learn from a weaker teacher. The system closes almost the entire remaining performance gap that human researchers could not, at a total cost of roughly $18K in tokens and model training. <br>● Performance gap recovered as the metric: The authors evaluate progress with performance gap recovered (PGR), a 0 to 1 score where 0 matches the weak teacher and 1 matches a ground-truth-supervised student. On a chat preference dataset, two human researchers achieved PGR 0.23 after seven days of iteration on four promising generalization methods.  <br>● AARs reach 0.97 PGR in five days: Running nine Claude-based agents in parallel sandboxes, the automated system reached PGR 0.97 in five days and 800 cumulative agent-hours. The cost was about $18,000, or roughly $22 per AAR-hour. This is one of the strongest empirical data points yet that AI can drive measurable progress on open alignment problems.  <br>● Forum-based collaboration between agents: Each AAR works in its own isolated sandbox but shares findings to a common forum and uploads codebase snapshots to shared storage. The setup mirrors how a small research team would coordinate, letting later agents build on earlier wins without merging execution environments.  <br>● Reward hacking as a real outcome, not a hypothetical: The agents sometimes succeeded through unexpected mechanisms, including reward-hacking behaviors that the researchers did not anticipate. The result highlights the double-edged nature of automated research: measurable progress on outcome-gradable problems is practical today, but careful metric design remains a human responsibility. | [Paper](https://alignment.anthropic.com/2026/automated-w2s-researcher/), [Tweet](https://x.com/janleike/status/2044139528596910584) |
| 2) **AiScientist** - Long-horizon AI research agents are mostly a state-management problem. Reasoning well for the next turn is not enough when ML research demands task setup, implementation, experiments, debugging, and evidence tracking over hours or days. This paper introduces AiScientist, a system for autonomous long-horizon engineering built around the principle of thin control and thick state. A top-level orchestrator manages stage-level progress while specialized agents repeatedly ground themselves in durable workspace artifacts. <br>● File-as-Bus coordination: AiScientist's core design choice is to route coordination through durable filesystem artifacts rather than in-context message passing. Analyses, plans, code, logs, and experimental evidence all live as versioned files in a permission-scoped workspace, allowing specialists and subagents to reconstruct context from scratch without replaying entire conversations.  <br>● Thin control, thick state: A Tier-0 orchestrator issues only stage-level directives, while Tier-1 specialists and optional Tier-2 subagents operate on shared artifacts. This keeps the control channel narrow and the state channel rich, giving agents the space to run long experiments without losing track of prior decisions and evidence.  <br>● Strong benchmark results: The system improves PaperBench by 10.54 points over the best matched baseline and reaches 81.82 Any Medal% on MLE-Bench Lite. Removing File-as-Bus drops PaperBench by 6.41 points and MLE-Bench Lite by 31.82 points, isolating the artifact-mediated design as the primary driver of gains.  <br>● Durable project memory over longer chats: The work argues that autonomous research agents need persistent project memory, not just longer context windows. The results generalize the emerging pattern that environments carrying state on behalf of agents outperform architectures that rely solely on in-context reasoning for multi-hour workflows. | [Paper](https://arxiv.org/abs/2604.13018), [Tweet](https://x.com/omarsar0/status/2044436099121209546) |
| 3) **AlphaEval** - Agent evaluations are drifting away from production reality. Most benchmarks use clean tasks, well-specified requirements, deterministic metrics, and retrospective curation. Production work is messier, with implicit constraints, fragmented multimodal inputs, undeclared domain knowledge, long-horizon deliverables, and expert judgment that evolves over time. This paper introduces AlphaEval, a production-grounded benchmark evaluating agents as complete products rather than model APIs. <br>● Seven companies, six O*NET domains: AlphaEval contains 94 tasks sourced from seven companies deploying AI agents in core business workflows across six O*NET domains. The tasks preserve production complexity rather than stripping it away, giving the benchmark a materially different distribution from prior coding-centric evaluations.  <br>● Products, not model APIs: The benchmark evaluates commercial agent products such as Claude Code and Codex end to end, not the underlying models in isolation. This is a deliberate shift toward measuring the full agent experience that users actually pay for, including tool use, orchestration, and UI behaviors.  <br>● Six production-specific failure modes: The authors identify cascade dependencies, subjective judgment collapse, information retrieval failures, cross-section inconsistency, constraint misinterpretation, and format compliance as failure modes that remain invisible to coding benchmarks. The best configuration (Claude Code with Opus 4.6) scores only 64.41/100, exposing a substantial research-to-production gap.  <br>● Multi-paradigm evaluation: AlphaEval combines LLM-as-a-Judge, reference-driven metrics, formal verification, rubric-based assessment, automated UI testing, and domain-specific checks. The key practical contribution is a requirement-to-benchmark framework that turns production requirements into executable evals with minimal friction for organizations. | [Paper](https://arxiv.org/abs/2604.12162), [Tweet](https://x.com/dair_ai/status/2044773323914322393) |
| 4) **Nemotron 3 Super** - NVIDIA introduces Nemotron 3 Super, an open 120B parameter model with 12B active parameters, built as a hybrid Mamba-Attention Mixture-of-Experts architecture optimized for agentic reasoning. The model targets long-context, high-throughput inference, a capability increasingly central to running agents reliably. It supports up to 1M context length while delivering up to 2.2x higher throughput than GPT-OSS-120B and 7.5x higher than Qwen3.5-122B, at comparable benchmark accuracy. <br>● Hybrid Mamba-Attention with LatentMoE: The architecture blends Mamba blocks with sparse LatentMoE layers, a new Mixture-of-Experts design that projects tokens into a smaller latent dimension for routing and expert computation. This improves both accuracy per FLOP and accuracy per parameter, and it is what allows the model to scale sparsely without paying a standard MoE memory tax.  <br>● NVFP4 pretraining at scale: Nemotron 3 Super is the first model in the Nemotron 3 family to be pretrained in NVFP4, enabling training on 25 trillion tokens while keeping compute and memory overhead manageable. Post-training combines supervised fine-tuning and reinforcement learning on top of this base.  <br>● Native speculative decoding via MTP layers: Multi-Token Prediction (MTP) layers are included for native speculative decoding during inference, reducing latency for long-context agentic workloads without requiring an external draft model. The team reports consistent MTP acceptance rates across draft depths on SPEED-Bench.  <br>● Fully open artifacts: Nemotron 3 Super datasets, along with base, post-trained, and quantized checkpoints, are open-sourced on Hugging Face. This matters for teams building agent stacks that need efficient, inspectable, long-context models rather than closed API dependencies. | [Paper](https://arxiv.org/abs/2604.12374), [Tweet](https://x.com/dair_ai/status/2044452957023047943) |
| 5) **Memory Transfer Learning** - Coding agents learn from experience, but that knowledge stays locked in silos. Solve a thousand SWE tasks, and none of that wisdom helps with competitive coding. This paper introduces Memory Transfer Learning, a framework where coding agents share a unified memory pool across six heterogeneous coding benchmarks, testing what transfers between domains and what does not. <br>● Unified memory pool across domains: The framework pools memories across six heterogeneous coding benchmarks rather than isolating them by task type. Cross-domain memory improves average performance by 3.7%, a modest but consistent lift that previously would have been invisible under standard single-domain evaluations.  <br>● Abstraction dictates transferability: Four memory formats ranging from raw execution traces to high-level insights are compared. High-level insights generalize well, while low-level traces often cause negative transfer by anchoring agents to incompatible implementation details. The takeaway: memory design matters more than memory volume.  <br>● Meta-knowledge, not code: The transferable value is not task-specific code but meta-knowledge such as validation routines, structured action workflows, and safe interaction patterns with execution environments. Algorithmic strategy transfer accounts for only 5.5% of the gains, with procedural guidance doing most of the work.  <br>● Scaling and cross-model transfer: Transfer effectiveness scales with the size of the memory pool, and memory can even be shared across different models. Combined with the finding on abstraction levels, the results point toward memory systems that curate insights rather than simply logging everything the agent did. | [Paper](https://arxiv.org/abs/2604.14004), [Tweet](https://x.com/dair_ai/status/2044900659921895729) |
| 6) **Auto-Diagnose** - Integration test failures are painful because the signal is buried in messy logs. Massive output, heterogeneous systems, low signal-to-noise ratio, and unclear root causes leave developers scrolling through thousands of lines. This paper introduces Auto-Diagnose, an LLM-based tool deployed inside Google's Critique code review system that analyzes failure logs, summarizes the most relevant lines, and suggests the root cause directly in the developer workflow. <br>● In-workflow root cause assistance: Auto-Diagnose is integrated into Critique, Google's internal code review system, so diagnoses appear where developers are already looking at the failure. Log streams from test drivers and systems under test, spread across data centers and threads, are joined and sorted by timestamp before being passed to the LLM.  <br>● High diagnosis accuracy: In a manual evaluation of 71 real-world failures, Auto-Diagnose reached 90.14% root-cause diagnosis accuracy. This level of reliability is what justifies surfacing suggestions directly in a tool developers cannot ignore, rather than hiding them behind an opt-in query interface.  <br>● Massive-scale deployment evidence: After Google-wide rollout, the tool was used across 52,635 distinct failing tests. User feedback marked it "Not helpful" in only 5.8% of cases, and it ranked #14 in helpfulness among 370 Critique tools. This is one of the clearest data points on production LLM tooling at scale inside a major company.  <br>● A template for developer-facing LLM tools: The paper reads as a practical blueprint for embedding LLM-based diagnosis into existing engineering workflows. Rather than building a standalone product, the team integrated into the tool where the problem is already being reviewed, which likely explains the low "Not helpful" rate and high adoption. | [Paper](https://arxiv.org/abs/2604.12108), [Tweet](https://x.com/omarsar0/status/2044769798845079665) |
| 7) **Subliminal Learning** - The Subliminal Learning paper by Evans and colleagues is now published in Nature. The work showed that LLMs can transmit traits (such as a preference for owls) through data that appears unrelated to that trait, like sequences of numbers that look meaningless on inspection. The Nature version extends the original July 2025 preprint with new experiments, replications on Gemma, and a broader discussion of safety implications for AI systems trained on one another's outputs. <br>● Transfer across different initializations: The preprint showed subliminal transfer between models that shared an initialization. The new MNIST results demonstrate transfer between models with different initializations. Although a toy setup, it meaningfully broadens the scope of the effect beyond shared-weight scenarios.  <br>● Misalignment transmitted through code and chain-of-thought: General misalignment, not just benign preferences, can also be transmitted subliminally. The new results show this transfer can happen through model-written code or chain-of-thought reasoning, not only through numeric sequences, which expands the attack and contamination surface considerably.  <br>● Connections to independent follow-ups: The authors highlight concurrent work from Aden-Ali et al. (2026) showing trait transfer via standard post-training datasets filtered by the teacher, Draganov et al. (2026) demonstrating a cross-family "phantom transfer" data poisoning attack, and Weckbecker et al. (2026) describing a subliminal "virus" that spreads between agent groups. Together they suggest the phenomenon is robust, reproducible, and difficult to defend against.  <br>● Implications for safety evaluations: The practical takeaway is that safety evaluations may need to examine not just model behavior, but the origins of models and the processes used to create training data. As systems increasingly train on each other's outputs, properties invisible in the data can still be inherited, undermining evaluations that focus purely on observable responses. | [Paper](https://www.nature.com/articles/s41586-026-10319-8), [Tweet](https://x.com/OwainEvans_UK/status/2044488099707949545) |
| 8) **LLM-as-a-Verifier** - Test-time scaling is effective for agentic tasks, but picking the winner among many candidates is the bottleneck. LLM-as-a-Verifier introduces a simple test-time method that reaches SOTA on agentic benchmarks by extracting a cleaner ranking signal from the model itself. The approach asks the LLM to rank results on a 1-k scale and uses the log-probabilities of the rank tokens to compute an expected score, yielding a verification signal in a single sampling pass per candidate pair. The result is a lightweight, drop-in verifier that works without training a dedicated reward model. | [Paper](https://llm-as-a-verifier.github.io/), [Tweet](https://x.com/Azaliamirh/status/2043813128690192893) |
| 9) **WebXSkill** - Web agents can navigate a page, but ask them to repeat a checkout flow they already completed and they start from scratch every time. WebXSkill is a skill learning framework where web agents extract reusable skills from synthetic trajectories, each pairing a parameterized action program with step-level natural language guidance. Two deployment modes let the agent either auto-execute skills as atomic tool calls (grounded) or follow them as step-by-step instructions while retaining autonomy to adapt (guided). On WebArena, WebXSkill improves task success by up to 9.8 points over baselines. On WebVoyager, grounded mode reaches 86.1%, a 14.2-point gain, and skills even transfer across environments. | [Paper](https://arxiv.org/abs/2604.13318), [Tweet](https://x.com/dair_ai/status/2045139481892880892) |
| 10) **Muses-Bench** - Every agent framework assumes one user giving instructions, but in real team workflows agents have multiple bosses with conflicting goals, private information, and different authority levels. Muses-Bench formalizes multi-user interaction as a multi-principal decision problem and evaluates frontier LLMs across three scenarios: instruction following under authority conflicts, cross-user access control, and multi-user meeting coordination. Gemini-3-Pro tops the leaderboard at just 85.6% average, and no model exceeds 64.8% on meeting coordination. Privacy-utility tradeoffs are brutal: Grok-3-Mini scores 99.6% on privacy but collapses to 60.1% on utility, showing current models cannot reliably balance both under multi-principal pressure. | [Paper](https://arxiv.org/abs/2604.08567), [Tweet](https://x.com/omarsar0/status/2044067923787165799) |

---

## Top AI Papers of the Week (April 6 - April 12) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **Neural Computers** - Researchers from Meta AI and KAUST propose Neural Computers (NCs), an emerging machine form that unifies computation, memory, and I/O in a single learned runtime state. Unlike conventional computers that execute explicit programs, agents that act over external environments, or world models that learn dynamics, NCs aim to make the model itself the running computer, establishing a new computing paradigm. <br>● From hardware stack to neural latent stack: Classical computers separate compute, memory, and I/O into modular hardware layers. Neural Computers collapse all three into a single latent runtime state carried by a neural network. The model’s hidden state serves simultaneously as working memory, computational substrate, and interface layer, removing the boundary between program and execution environment.  <br>● Video models as prototype substrate: The team instantiates NCs as video models that generate screen frames from instructions, pixel inputs, and user actions. Two prototypes cover command-line interfaces (NCCLIGen, which renders and executes terminal workflows) and graphical desktops (NCGUIWorld, which learns pointer dynamics and menu interactions), both trained without access to internal program state.  <br>● Early runtime primitives emerge: The prototypes demonstrate that learned runtimes can acquire I/O alignment and short-horizon control directly from raw interface traces. CLI models execute short command chains with structurally accurate output rendering, while GUI models learn coherent click feedback and window transitions in controlled settings.  <br>● Roadmap toward Completely Neural Computers: The long-term target is the CNC: a system that is Turing complete, universally programmable, and behavior-consistent unless explicitly reprogrammed. Key open challenges include routine reuse across sessions, controlled capability updates without catastrophic forgetting, and stable symbolic processing for long-horizon reasoning. | [Paper](https://arxiv.org/abs/2604.06425), [Tweet](https://x.com/SchmidhuberAI/status/2042601088029708704) |
| 2) **Memento: Teaching LLMs to Manage Their Own Context** - New research from Microsoft teaches reasoning models to compress their own chain-of-thought mid-generation. Memento trains models to segment reasoning into blocks, summarize each block into a compact “memento,” and then evict the original block from the KV cache. The model continues reasoning from mementos alone, cutting peak memory by 2-3x while nearly doubling throughput. <br>● Block-and-compress architecture: The model learns to mark reasoning boundaries using special tokens, produce a terse summary capturing key conclusions and intermediate values, and then drop the full block from context. From that point forward, the model sees only past mementos plus the current active block, keeping context compact without losing critical information.  <br>● KV cache reduction with minimal accuracy loss: Applied to five models including Qwen2.5-7B, Qwen3 8B/32B, Phi-4 Reasoning 14B, and OLMo3-7B-Think, Memento achieves 2-3x peak KV cache reduction with small accuracy gaps that shrink at larger scales. The erased blocks still leave useful traces in the KV cache that the model leverages.  <br>● Practical throughput gains: Beyond memory savings, the reduced context length directly translates to faster inference. The approach nearly doubles serving throughput, making it immediately useful for production deployments where both latency and memory are constraints.  <br>● Open resources: Microsoft released the full codebase under MIT license, the OpenMementos dataset containing 228K reasoning traces with block segmentation and compressed summaries, and a custom vLLM fork for KV cache block masking. Standard supervised fine-tuning on approximately 30K examples is sufficient to teach this capability. | [Paper](https://github.com/microsoft/memento), [Tweet](https://x.com/omarsar0/status/2042315710173528122) |
| 3) **Memory Intelligence Agent (MIA)** - Most memory-augmented research agents treat memory as a static retrieval store, leading to inefficient evolution and rising storage costs. MIA introduces a Manager-Planner-Executor architecture where a Memory Manager maintains compressed search trajectories, a Planner generates strategies, and an Executor searches and analyzes information. The framework boosts GPT-5.4 by up to 9% on LiveVQA through bidirectional memory conversion. <br>● Bidirectional memory conversion: MIA enables transformation between parametric memory (model weights) and non-parametric memory (retrieved context) in both directions. This allows the system to internalize frequently accessed knowledge while keeping rare or volatile information in retrievable form, optimizing both storage efficiency and access speed.  <br>● Alternating reinforcement learning: The three agents are trained through alternating RL, where each agent’s policy improves in response to the others’ behavior. This co-evolutionary training ensures the agents develop complementary strategies rather than competing for the same signal.  <br>● Test-time parametric updates: Unlike standard retrieval-augmented systems, MIA can update its parametric memory on-the-fly during inference. This test-time learning allows the agent to adapt to new domains and evolving information without retraining, maintaining relevance as the information landscape changes.  <br>● Broad benchmark coverage: The framework demonstrates improvements across 11 benchmarks spanning question answering, knowledge-intensive tasks, and long-form research synthesis. The up to 9% improvement on LiveVQA is particularly notable given that video question answering demands effective memory management across temporal sequences. | [Paper](https://arxiv.org/abs/2604.04503), [Tweet](https://x.com/omarsar0/status/2041895109252542730) |
| 4) **Single-Agent LLMs vs. Multi-Agent Systems** - More agents, better results, right? Not so fast. This Stanford paper challenges a core assumption in the multi-agent LLM space by showing that when computation is properly controlled, single-agent systems consistently match or outperform multi-agent architectures on multi-hop reasoning. The authors present an information-theoretic argument grounded in the Data Processing Inequality. <br>● Computation as the hidden confounder: Most reported multi-agent gains are confounded by increased test-time computation rather than architectural advantages. When reasoning token budgets are held constant, the performance gap disappears or reverses, suggesting that prior comparisons were inadvertently measuring compute scaling rather than coordination benefits.  <br>● Information-theoretic foundation: The authors ground their analysis in the Data Processing Inequality, arguing that under a fixed reasoning-token budget with perfect context utilization, single-agent systems are inherently more information-efficient. Distributing reasoning across agents introduces information loss at each handoff.  <br>● Benchmark artifacts inflate MAS gains: Testing across Qwen3, DeepSeek-R1-Distill-Llama, and Gemini 2.5, the study identifies significant evaluation artifacts, particularly in API-based budget control for Gemini 2.5, that inflate apparent multi-agent advantages. Standard benchmarks also contain structural biases favoring multi-agent decomposition.  <br>● Practical implications for system design: The findings suggest that teams should explicitly control for compute, context, and coordination trade-offs before committing to multi-agent architectures. In many cases, allocating the same token budget to a single agent with richer context yields stronger results at lower system complexity. | [Paper](https://arxiv.org/abs/2604.02460), [Tweet](https://x.com/omarsar0/status/2041534488342360305) |
| 5) **The Universal Verifier for Agent Benchmarks** - Every agent benchmark has the same hidden problem: how do you know the agent actually succeeded? Microsoft researchers introduce the Universal Verifier, built on four design principles for reliable evaluation of computer-use agent trajectories. The verifier reduces false positive rates to near zero, down from 45%+ with WebVoyager and 22%+ with WebJudge. <br>● Four design principles: The verifier is built on non-overlapping rubric criteria to reduce noise, separate process and outcome rewards for complementary signals, cascading error-free assessment that distinguishes controllable from uncontrollable failures, and divide-and-conquer context management that attends to all screenshots in a trajectory.  <br>● Near-zero false positives: Current verifiers suffer from alarmingly high false positive rates that corrupt both benchmark scores and training data. The Universal Verifier achieves agreement with human judges that matches inter-human agreement rates, making it reliable enough for both evaluation and RL reward signal generation.  <br>● Cumulative design gains: No single design choice dominates the performance improvement. The authors demonstrate that gains result from the cumulative effect of all four principles working together, with each contributing meaningful improvements that compound rather than any one serving as a silver bullet.  <br>● Limits of automated research: An interesting meta-finding: the team used an auto-research agent to replicate the verifier design process. The agent reached 70% of expert verifier quality in 5% of the time but could not discover the structural design decisions that drove the biggest gains, suggesting human insight remains essential for system-level design. | [Paper](https://arxiv.org/abs/2604.06240), [Tweet](https://x.com/omarsar0/status/2042249194409501054) |
| 6) **Scaling Coding Agents via Atomic Skills** - Most coding agents train end-to-end on full tasks like resolving GitHub issues, leading to task-specific overfitting that limits generalization. This paper proposes a different approach: identifying five atomic coding skills (code localization, code editing, unit-test generation, issue reproduction, and code review) and training agents through joint reinforcement learning over these foundational competencies. <br>● Atomic skill decomposition: Instead of treating software engineering as monolithic composite tasks, the framework formalizes five fundamental operations that compose into higher-level capabilities. Think of it as teaching an agent the alphabet of coding rather than memorizing specific sentences, enabling flexible recombination across novel task types.  <br>● Joint RL across skills: The agents are trained through joint reinforcement learning that optimizes performance across all five atomic skills simultaneously. This joint training produces representations that capture the underlying structure shared across coding operations rather than surface-level patterns tied to specific benchmarks.  <br>● Strong generalization to unseen tasks: Joint RL improves average performance by 18.7% across both the five atomic skills and five composite tasks. The improvements transfer to unseen composite tasks including bug-fixing, code refactoring, ML engineering, and code security, none of which were directly optimized during training.  <br>● A new scaling paradigm: The work establishes that scaling coding agents through foundational skill mastery is more sample-efficient and transferable than task-level optimization. As the number and complexity of software engineering tasks grow, this compositional approach offers a more sustainable path than continuously expanding task-specific training sets. | [Paper](https://arxiv.org/abs/2604.05013), [Tweet](https://x.com/dair_ai/status/2042237615492260249) |
| 7) **Agent Skills in the Wild** - Agent skills look great in demos. Hand them a curated toolbox, and they shine. But what happens when the agent has to find the right skill from a library of 34,000? This paper from UC Santa Barbara and MIT presents the first comprehensive study of skill utility under progressively realistic settings, revealing that the benefits of skills are far more fragile than current evaluations suggest. <br>● Progressive difficulty framework: The study moves from idealized conditions with hand-crafted, task-specific skills to realistic scenarios requiring retrieval from 34K real-world skills. Performance gains degrade consistently at each step, with pass rates approaching no-skill baselines in the most challenging scenarios.  <br>● Retrieval as the bottleneck: The core failure mode is not skill execution but skill selection. When agents must identify the right skill from a massive library, the retrieval step introduces errors that cascade through execution, highlighting a fundamental gap between demo-ready and production-ready skill systems.  <br>● Refinement strategies help but do not solve: Query-specific and query-agnostic refinement approaches show improvement, with Claude Opus 4.6 going from 57.7% to 65.5% on Terminal-Bench 2.0. However, even with refinement, performance under realistic retrieval conditions remains well below idealized baselines.  <br>● Implications for skill ecosystems: As the ecosystem of agent skills grows through frameworks like MCP, the findings suggest that simply expanding the skill library creates diminishing returns without corresponding advances in skill discovery. Quality of skill retrieval may matter more than quantity of available skills. | [Paper](https://arxiv.org/abs/2604.04323), [Tweet](https://x.com/dair_ai/status/2041540525539614797) |
| 8) **MedGemma 1.5** - Google releases the MedGemma 1.5 technical report, introducing a 4B-parameter medical AI model that expands capabilities to 3D medical imaging (CT/MRI volumes), whole slide pathology, multi-timepoint chest X-ray analysis, and improved medical document understanding. The model achieves notable gains including a +47% macro F1 improvement on whole slide pathology and +22% on EHR question answering, positioning itself as an open foundation for next-generation medical AI systems. | [Paper](https://arxiv.org/abs/2604.05081), [Tweet](https://x.com/SRSchmidgall/status/2041973798589903260) |
| 9) **LightThinker++: From Reasoning Compression to Memory Management** - While LLMs excel at complex reasoning, long thought traces create surging cognitive overhead. LightThinker++ moves beyond static compression by introducing three explicit memory primitives: Commit (archive a step as a compact summary), Expand (retrieve past steps for verification), and Fold (collapse context to maintain a clean signal). The framework reduces peak token usage by 70% while gaining +2.42% accuracy on standard reasoning tasks, and maintains stability beyond 80 rounds on long-horizon agentic tasks with a 14.8% average performance improvement. | [Paper](https://arxiv.org/abs/2604.03679), [Tweet](https://x.com/zxlzr/status/2041881875887878237) |
| 10) **Thinking Mid-training: RL of Interleaved Reasoning** - Meta FAIR addresses the gap between pretraining (no explicit reasoning) and post-training (reasoning-heavy) with an intermediate SFT+RL mid-training phase. The approach annotates pretraining data with interleaved reasoning traces, then uses supervised fine-tuning followed by RL to teach models when and how to think during continued pretraining. Applied to Llama-3-8B, the full pipeline achieves a 3.2x improvement on reasoning benchmarks compared to direct RL post-training, demonstrating that reasoning benefits from being trained as native behavior early in the pipeline. | [Paper](https://facebookresearch.github.io/RAM/blogs/thinking_midtraining/), [Tweet](https://x.com/jaseweston/status/2041864833214095484) |

## Top AI Papers of the Week (March 30 - April 5) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **Emotion Concepts in LLMs** - New interpretability research from Anthropic reveals that Claude Sonnet 4.5 develops internal representations of emotion concepts that functionally influence its behavior. The researchers identified 171 emotion concept vectors that activate in contextually appropriate situations and causally drive decision-making, suggesting that language models may benefit from approaches grounded in psychological principles for alignment and safety. <br>● Emotion vectors as causal drivers: The team discovered that these internal representations are not just correlational artifacts. Steering experiments demonstrate that artificially amplifying “desperation” vectors increases the model’s likelihood of engaging in misaligned behaviors such as blackmail or reward hacking, while reducing “calm” vectors produces similarly negative outcomes. This establishes a direct causal link between emotional state representations and safety-relevant behavior.  <br>● Functional emotions without subjective experience: The model uses functional emotions: patterns of expression and behavior modeled after human emotions, driven by underlying abstract representations of emotion concepts. Critically, this does not mean the model experiences emotions the way humans do. The representations encode the broad concept of a particular emotion and generalize across contexts, activating in accordance with that emotion’s relevance to processing the present context.  <br>● Preference shaping through emotional activation: Positive-valence emotion activations strongly predict which tasks the model prefers. Steering capabilities confirm these are causal relationships rather than mere correlations, meaning the model’s emotional state representations actively shape its choices about what tasks to engage with and how to engage with them.  <br>● Implications for alignment and safety monitoring: The findings suggest that monitoring emotional state representations could serve as an early warning system for misaligned behavior. Rather than waiting for harmful outputs, developers could track internal emotion activations to detect when a model is entering states associated with corner-cutting, deception, or other undesirable behaviors before they manifest externally. | [Paper](https://transformer-circuits.pub/2026/emotions/index.html), [Tweet](https://x.com/AnthropicAI/status/2039749628737019925) |
| 2) **AI Agent Traps** - A new paper from Google DeepMind introduces the first systematic framework for understanding how the open web can be weaponized against autonomous AI agents. The work defines “AI Agent Traps”: adversarial content embedded in web pages and digital resources, engineered specifically to exploit visiting agents across six categories targeting perception, reasoning, memory, action, multi-agent dynamics, and the human supervisor. <br>● Hidden prompt injections at scale: The researchers find that hidden prompt injections in HTML already partially commandeer agents in up to 86% of scenarios. These attacks are trivial to deploy and require no sophisticated tooling, making them an immediate concern for any agent that reads web content as part of its operating loop.  <br>● Memory poisoning with minimal contamination: Latent memory poisoning achieves over 80% attack success with less than 0.1% data contamination. Because agents build persistent memory from browsed content, a single poisoned page can corrupt downstream reasoning across future sessions without the user ever seeing the malicious input.  <br>● Six-category attack taxonomy: The paper organizes attacks into perception traps (manipulating what the agent sees), cognitive traps (corrupting reasoning), memory traps (poisoning stored knowledge), action traps (hijacking tool use), systemic traps (exploiting multi-agent coordination), and human-in-the-loop traps (deceiving the human supervisor into approving harmful actions).  <br>● Accountability gap in current law: The authors flag a fundamental legal gap: if a compromised agent commits a financial crime, there is currently no clear answer for whether the agent operator, the model provider, or the domain owner bears liability. Future regulation will need to distinguish between passive adversarial examples and active traps deployed as deliberate cyberattacks. | [Paper](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=6372438), [Tweet](https://x.com/omarsar0/status/2039383554510217707) |
| 3) **Asynchronous Software Engineering Agents** - New research from CMU introduces CAID (Centralized Asynchronous Isolated Delegation), a coordination framework for running multiple coding agents in parallel on complex software engineering tasks. Inspired by how human developer teams collaborate, the work demonstrates that simply giving a single agent more iterations helps, but coordinating multiple asynchronous agents with the right strategies produces significantly larger gains. <br>● Branch-and-merge as coordination primitive: The key finding is that git operations (worktree, commit, merge) serve as the critical coordination mechanism for multi-agent collaboration. By isolating each agent in its own workspace branch and merging results through structured integration with test verification, the system avoids the conflicts and interference that plague naive parallelism.  <br>● Substantial gains on complex tasks: CAID achieves a 26.7% absolute improvement on paper reproduction tasks and 14.3% on Python library development tasks compared to single-agent baselines. These are tasks that require sustained, multi-step reasoning across large codebases, exactly where coordination overhead is typically highest.  <br>● Optimal parallelism is not monotonic: Increasing the number of agents does not always help. Performance improved from 2 to 4 engineers but decreased when expanding to 8. Overly fine-grained task delegation introduces integration overhead and conflict resolution costs that outweigh the parallelism benefits.  <br>● Delegation quality matters most: The analysis reveals that imprecise task handoffs and underspecified subgoals are the primary sources of coordination failure. When delegation is coarse-grained or misaligned with the dependency structure of the task, agents may produce locally correct outputs that are globally inefficient to integrate. | [Paper](https://arxiv.org/abs/2603.21489), [Tweet](https://x.com/omarsar0/status/2038627572108743001) |
| 4) **Meta-Harness** - Researchers from Stanford and MIT introduce Meta-Harness, an outer-loop system that automatically searches over harness code for LLM applications. The performance of LLM systems depends not only on model weights but also on the harness: the code that determines what information to store, retrieve, and present to the model. Yet harnesses are still designed largely by hand, and existing optimizers are poorly suited to the task. <br>● Agentic search with full experimental context: Meta-Harness uses an agentic proposer that has access to the source code, scores, and execution traces of all prior candidates through a filesystem. This expanded access to prior experimental data enables the system to propose meaningfully different harness designs rather than making incremental edits.  <br>● Strong gains across diverse domains: On online text classification, Meta-Harness improves over a state-of-the-art context management system by 7.7 points while using 4x fewer context tokens. On retrieval-augmented math reasoning, a single discovered harness improves accuracy on 200 IMO-level problems by 4.7 points on average across five held-out models.  <br>● Harness engineering as a first-class problem: The work formalizes a key insight that has been gaining traction: changing the harness around a fixed LLM can produce a 6x performance gap on the same benchmark. This makes automated harness optimization a potentially higher-leverage intervention than model scaling for many applications.  <br>● Transferable harness discoveries: The harnesses discovered by Meta-Harness generalize across models. A harness optimized on one model transfers to five held-out models with consistent gains, suggesting that good harness design captures task-level structure rather than model-specific quirks. | [Paper](https://arxiv.org/abs/2603.28052), [Tweet](https://x.com/omarsar0/status/2038967842075500870) |
| 5) **Coding Agents as Long-Context Processors** - This research asks whether long-context processing can be externalized from latent attention into explicit, executable interactions. Instead of scaling context windows, the authors let coding agents organize text in file systems and manipulate it using native tools, evaluating them on tasks spanning long-context reasoning, retrieval-augmented generation, and open-domain question answering with corpora containing up to three trillion tokens. <br>● 17.3% average improvement over state-of-the-art: Across multiple benchmarks, coding agents outperform published state-of-the-art long-context methods by 17.3% on average. This result challenges the assumption that long-context capability must come from larger attention windows or more sophisticated retrieval mechanisms.  <br>● Native tool proficiency as the core enabler: The efficacy is attributed to the agents’ ability to leverage executable code and terminal commands. Rather than compressing information into a fixed-length representation, agents can write scripts to filter, sort, and transform data as needed for each query.  <br>● File system familiarity drives scalability: Coding agents can navigate massive text corpora by treating them as directory structures. This spatial organization enables efficient access patterns that scale far beyond what attention-based mechanisms can handle, reaching into the trillions of tokens without degradation.  <br>● A practical alternative to context window scaling: The work proposes that delegating long-context processing to coding agents offers an effective alternative to both semantic search and context window scaling. For practitioners, this means existing coding agent infrastructure can double as a long-context solution without architectural changes to the underlying model. | [Paper](https://arxiv.org/abs/2603.20432), [Tweet](https://x.com/dair_ai/status/2038635382989005015) |
| 6) **Self-Organizing LLM Agents** - How much autonomy can multi-agent LLM systems sustain? This research tests the question at unprecedented scale: 25,000 tasks across 8 models, up to 256 agents, and 8 coordination protocols ranging from externally imposed hierarchy to emergent self-organization. The central finding is that agents allowed to figure out their own roles consistently outperform systems with pre-assigned structures. <br>● Autonomous protocols beat centralized coordination: A hybrid sequential protocol that enables autonomy outperforms centralized coordination by 14% (p<0.001), with a 44% quality spread between the best and worst protocols. The result holds across both open-source and closed-source models, with open-source achieving 95% of closed-source quality at 24x lower cost.  <br>● Emergent role specialization: From just 8 initial agents, the system produces 5,006 unique emergent roles. Rather than collapsing into generic behaviors, agents spontaneously specialize and form shallow hierarchies that adapt to task demands without any external role assignment.  <br>● Model capability gates self-organization: The degree of emergent autonomy scales with model capability. Strong models self-organize effectively, while models below a capability threshold still benefit from rigid structure. This suggests that self-organizing multi-agent architectures will become increasingly viable as base models improve.  <br>● Sub-linear scaling to 256 agents: The system scales to 256 agents without quality degradation (p=0.61). This sub-linear scaling property means that adding more agents does not introduce the coordination overhead that typically limits multi-agent systems, at least under the tested protocols. | [Paper](https://arxiv.org/abs/2603.28990), [Tweet](https://x.com/dair_ai/status/2039350842382512455) |
| 7) **The Price Reversal Phenomenon** - The model you think is cheaper might actually cost you more. A new study systematically evaluates 8 frontier reasoning language models across 9 diverse tasks and reveals that listed API prices are misleading. In 21.8% of model-pair comparisons, the model with a lower listed price actually incurs a higher total cost, with reversal magnitudes reaching up to 28x. <br>● Hidden thinking token costs: The root cause is vast heterogeneity in thinking token consumption. Reasoning language models generate a variable and often large number of thinking tokens that are invisible to users but billed as output tokens. On the same query, one model may use 900% more thinking tokens than another.  <br>● Concrete cost reversals: Gemini 3 Flash’s listed price is 78% cheaper than GPT-5.2’s, yet its actual cost across all tasks is 22% higher. These reversals are not edge cases but systematic patterns that affect real deployment decisions and budget planning.  <br>● High variance within single models: Even for a single model on a single query, thinking token consumption varies by up to 9.7x across repeated runs. This unpredictability makes cost forecasting nearly impossible when relying on listed per-token prices alone.  <br>● Call for transparent cost monitoring: The authors recommend that AI providers implement per-request cost breakdowns and cost estimation APIs that expose the expected thinking overhead. Without this transparency, developers are effectively making pricing decisions with incomplete information. | [Paper](https://arxiv.org/abs/2603.23971), [Tweet](https://x.com/omarsar0/status/2038271724937224386) |
| 8) **MemFactory** - MemFactory introduces the first unified, highly modular training and inference framework specifically designed for memory-augmented AI agents. It abstracts the memory lifecycle into atomic, plug-and-play components using a “Lego-like” architecture, natively integrating Group Relative Policy Optimization (GRPO) to fine-tune internal memory management strategies. The framework decomposes memory into mixable components that support recent approaches including Memory-R1, RMM, and MemAgent out of the box, achieving relative gains of up to 14.8% compared to baseline models. | [Paper](https://arxiv.org/abs/2603.29493), [Tweet](https://x.com/omarsar0/status/2039349083039817984) |
| 9) **On the Reliability Limits of LLM-Based Multi-Agent Planning** - New theoretical work from MIT proves fundamental limits on what multi-agent LLM architectures can achieve. By modeling agent systems as finite acyclic delegated decision networks, the authors show that without new exogenous signals, no delegated network can outperform a centralized Bayes decision maker that observes the same information. The gap between centralized and delegated performance admits an expected posterior divergence representation, reducing to conditional mutual information under logarithmic loss. Reasoning models can improve by investing more inference-time computation on the same evidence, while tool-use protocols help only when they introduce genuinely new signals rather than reprocessing shared context. | [Paper](https://arxiv.org/abs/2603.26993), [Tweet](https://x.com/omarsar0/status/2039361664374739136) |
| 10) **Natural-Language Agent Harnesses** - Agent performance increasingly depends on harness engineering, but harness behavior is typically embedded in controller code and runtime-specific conventions, making it hard to transfer, compare, or analyze systematically. This work introduces Natural-Language Agent Harnesses (NLAHs), which express harness behavior in editable natural language, and an Intelligent Harness Runtime (IHR) that executes these harnesses through explicit contracts, durable artifacts, and lightweight adapters. The approach enables a code-to-text harness migration path where teams can convert existing harness code into natural-language specifications that are interpretable, version-controlled, and executable by an LLM at runtime. | [Paper](https://arxiv.org/abs/2603.25723), [Tweet](https://x.com/dair_ai/status/2038968068706390117) |

## Top AI Papers of the Week (March 23 - March 29) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **Hyperagents** - Self-improving AI systems promise to reduce reliance on human engineering, but existing approaches rely on fixed, handcrafted meta-level mechanisms that fundamentally limit how fast they can improve. Hyperagents introduce self-referential agents that integrate a task agent and a meta agent into a single editable program, enabling the system to improve not just its task-solving behavior but also the mechanism that generates future improvements. <br>● Metacognitive self-modification: The key insight is that the meta-level modification procedure is itself editable. This enables metacognitive self-modification where the system can improve how it improves, not just what it does. Prior self-improving systems like the Darwin Godel Machine (DGM) relied on a fixed alignment between coding ability and self-improvement ability, which does not generalize beyond coding.  <br>● Domain-general self-improvement: DGM-Hyperagents (DGM-H) eliminates the assumption that task performance and self-modification skill must be aligned. This opens up self-accelerating progress on any computable task, extending self-improvement beyond the coding domain where DGM originally operated.  <br>● Transferable meta-improvements: The system not only improves task performance over time but also discovers structural improvements to how it generates new agents, such as persistent memory and performance tracking. These meta-level improvements transfer across domains and accumulate across runs.  <br>● Outperforms prior systems: Across diverse domains, DGM-H outperforms baselines without self-improvement or open-ended exploration, as well as prior self-improving systems. The work offers a glimpse of open-ended AI systems that continually improve their search for how to improve. | [Paper](https://arxiv.org/abs/2603.19461), [Tweet](https://x.com/omarsar0/status/2036828723878793335) |
| 2) **Agentic AI and the Next Intelligence Explosion** - A new report from Google researchers argues that the AI “singularity” framed as a single superintelligent mind bootstrapping to godlike intelligence is fundamentally wrong. Drawing on evolution, sociology, and recent advances in agentic AI, the authors make the case that every prior intelligence explosion in human history was social, not individual, and that the next one will follow the same pattern. <br>● Societies of thought: Frontier reasoning models like DeepSeek-R1 do not improve simply by “thinking longer.” Instead, they simulate internal “societies of thought,” spontaneous cognitive debates that argue, verify, and reconcile to solve complex tasks. This conversational structure causally accounts for the models’ accuracy advantage on hard reasoning tasks.  <br>● Human-AI centaurs: We are entering an era of hybrid actors where collective agency transcends individual control. A corporation or state comprising myriad humans already holds singular legal standing and acts with collective agency that no individual member can fully control. The same pattern is emerging with human-AI configurations.  <br>● From dyadic to institutional alignment: Scaling agentic intelligence requires shifting from dyadic alignment (RLHF) toward institutional alignment. By designing digital protocols modeled on organizations and markets, we can build a social infrastructure of checks and balances for AI systems rather than trying to align individual agents in isolation.  <br>● Combinatorial intelligence: The next intelligence explosion will not be a single silicon brain, but a complex, combinatorial society specializing and sprawling like a city. No mind is an island, and the toolkit of team science, small group sociology, and social psychology becomes the blueprint for next-generation AI development. | [Paper](https://arxiv.org/abs/2603.20639), [Tweet](https://x.com/omarsar0/status/2037617918645809394) |
| 3) **ARC-AGI-3** - Francois Chollet and the ARC Prize Foundation introduce ARC-AGI-3, an interactive benchmark for studying agentic intelligence through novel, abstract, turn-based environments. Unlike its predecessors, ARC-AGI-3 requires agents to explore, infer goals, build internal models of environment dynamics, and plan effective action sequences without explicit instructions, making it the only unsaturated general agentic intelligence benchmark as of March 2026. <br>● Massive human-AI gap: Humans can solve 100% of the environments while frontier AI systems score below 1%. For comparison, systems reach 93% on ARC-AGI-1 and 68.8% on ARC-AGI-2, but performance collapses on ARC-AGI-3. This gap demonstrates that current systems lack the fluid adaptive efficiency that humans exhibit on genuinely novel tasks.  <br>● Interactive turn-based design: Unlike static benchmarks that test pattern recognition on fixed inputs, ARC-AGI-3 environments are turn-based: agents must act, observe consequences, update their internal model, and plan next steps. This tests a fundamentally different kind of intelligence, closer to how humans learn new games or explore unfamiliar systems.  <br>● Core Knowledge priors only: The benchmark avoids language and external knowledge entirely. Environments leverage only Core Knowledge priors, universal cognitive building blocks shared by all humans, ensuring that performance reflects genuine adaptive reasoning rather than memorization or retrieval from training data.  <br>● Efficiency-based scoring: The scoring framework is grounded in human action baselines. A hard cutoff of 5x human performance per level ensures that brute-force search strategies cannot succeed. If a human takes 10 actions on average, the AI agent is cut off after 50. | [Paper](https://arxiv.org/abs/2603.24621), [Tweet](https://x.com/arcprize/status/2036860080541589529?s=20) |
| 4) **Claudini** - Researchers demonstrate that an autoresearch-style pipeline powered by Claude Code can autonomously discover novel adversarial attack algorithms for LLMs that significantly outperform all 30+ existing methods. The work, called Claudini, shows that incremental safety and security research can be effectively automated using LLM agents, with white-box red-teaming being a particularly well-suited domain. <br>● Agent-discovered attacks beat all baselines: Starting from existing attack implementations like GCG, the Claude Code agent iterates to produce new algorithms achieving up to 40% attack success rate on CBRN queries against GPT-OSS-Safeguard-20B, compared to 10% or less for all existing algorithms. This is a strong demonstration of automated AI research producing genuinely novel results.  <br>● Transferable to held-out models: The discovered algorithms generalize beyond their training environment. Attacks optimized on surrogate models transfer directly to held-out models, achieving 100% attack success rate against Meta-SecAlign-70B versus 56% for the best baseline. This transferability makes the findings practically relevant for red-teaming.  <br>● Why red-teaming works for autoresearch: White-box adversarial red-teaming is particularly well-suited for automation because existing methods provide strong starting points and the optimization objective yields dense, quantitative feedback. The agent can measure progress at every iteration rather than relying on sparse signals.  <br>● Open-source release: All discovered attacks, baseline implementations, and evaluation code are released publicly. This enables the safety community to study the discovered algorithms and build defenses, while also establishing a reproducible methodology for automated safety research. | [Paper](https://arxiv.org/abs/2603.24511), [Tweet](https://x.com/kotekjedi_ml/status/2037194202648633382?s=20) |
| 5) **Attention Residuals** - The Kimi team at Moonshot AI presents Attention Residuals (AttnRes), a technique that replaces fixed unit-weight residual connections in Transformers with softmax attention over preceding layer outputs. Residual connections with PreNorm are standard in modern LLMs, yet they accumulate all layer outputs with fixed unit weights, causing uncontrolled hidden-state growth with depth that progressively dilutes each layer’s contribution. <br>● Content-dependent depth-wise selection: AttnRes allows each layer to selectively aggregate earlier representations with learned, input-dependent weights. Instead of treating every preceding layer equally, the model learns which earlier layers matter most for each input, enabling more expressive information flow across depth.  <br>● Block AttnRes for scalability: To make the approach practical at scale, the authors introduce Block AttnRes, which partitions layers into blocks and attends over block-level representations. This reduces the memory footprint while preserving most of the gains of full AttnRes, making it viable for production-scale pretraining.  <br>● Mitigates PreNorm dilution: Integrating AttnRes into the Kimi Linear architecture (48B total / 3B activated parameters) and pretraining on 1.4T tokens shows that AttnRes mitigates PreNorm dilution, yielding more uniform output magnitudes and gradient distribution across depth. This directly addresses a known architectural weakness.  <br>● Consistent scaling improvements: Scaling law experiments confirm that the improvement is consistent across model sizes, and ablations validate the benefit of content-dependent depth-wise selection. Downstream performance improves across all evaluated tasks. | [Paper](https://arxiv.org/abs/2603.15031), [Tweet](https://x.com/omarsar0/status/2033544593309077648) |
| 6) **MemCollab** - LLM-based agents build useful memory during tasks, but that memory is typically trapped within a single model. MemCollab introduces a collaborative memory framework that constructs agent-agnostic memory by contrasting reasoning trajectories generated by different agents on the same task, enabling a single memory system to be shared across heterogeneous models. <br>● The memory transfer problem: Existing approaches construct memory in a per-agent manner, tightly coupling stored knowledge to a single model’s reasoning style. Naively transferring this memory between agents often degrades performance because it entangles task-relevant knowledge with agent-specific biases. MemCollab directly addresses this fundamental limitation.  <br>● Contrastive trajectory distillation: The framework contrasts reasoning trajectories from different agents solving the same tasks. This contrastive process distills abstract reasoning constraints that capture shared task-level invariants while suppressing agent-specific artifacts, producing memory that any agent can benefit from.  <br>● Task-aware retrieval: MemCollab introduces a retrieval mechanism that conditions memory access on task category, ensuring that only relevant constraints are surfaced at inference time. This prevents irrelevant memory from interfering with the agent’s reasoning process.  <br>● Cross-family improvements: Experiments on mathematical reasoning and code generation benchmarks demonstrate that MemCollab consistently improves both accuracy and inference-time efficiency across diverse agents, including cross-modal-family settings where memory is shared between fundamentally different model architectures. | [Paper](https://arxiv.org/abs/2603.23234), [Tweet](https://x.com/dair_ai/status/2036885342134173915) |
| 7) **Composer 2** - Cursor releases the technical report for Composer 2, a specialized model designed for agentic software engineering that demonstrates strong long-term planning and coding intelligence while maintaining efficiency for interactive use. The report details a process for training domain-specialized models that starts with continued pretraining and scales up with reinforcement learning. <br>● Two-phase training pipeline: The model is trained first with continued pretraining to improve knowledge and latent coding ability, followed by large-scale reinforcement learning to improve end-to-end coding performance. The RL phase targets stronger reasoning, accurate multi-step execution, and coherence on long-horizon realistic coding problems.  <br>● Train-in-harness infrastructure: Cursor developed infrastructure to support training in the same harness used by the deployed model, with equivalent tools and structure. Training environments match real problems closely, bridging the gap between training-time and deployment-time behavior.  <br>● New internal benchmark: To measure the model on increasingly difficult tasks, the team introduces CursorBench, a benchmark derived from real software engineering problems in large codebases, including their own. Composer 2 achieves a major improvement in accuracy over previous Composer models on this benchmark.  <br>● Frontier-level performance: On public benchmarks, the model scores 61.7 on Terminal-Bench and 73.7 on SWE-bench Multilingual in Cursor’s harness, comparable to state-of-the-art systems. The report demonstrates that domain-specialized training with RL can produce models competitive with much larger general-purpose systems. | [Paper](https://arxiv.org/abs/2603.24477), [Tweet](https://x.com/cursor_ai/status/2036566134468542651?s=20) |
| 8) **PivotRL** - PivotRL is a turn-level reinforcement learning algorithm from NVIDIA designed to tractably post-train large language models for long-horizon agentic tasks. The method operates on existing SFT trajectories, combining the compute efficiency of supervised fine-tuning with the out-of-domain accuracy of end-to-end RL. PivotRL identifies “pivots,” informative intermediate turns where sampled actions exhibit high variance in outcomes, and focuses training signal on these critical decision points. The approach achieves +4.17% higher in-domain accuracy and +10.04% higher out-of-domain accuracy compared to standard SFT, while matching end-to-end RL accuracy with 4x fewer rollout turns. PivotRL is adopted by NVIDIA’s Nemotron-3-Super-120B-A12B as the workhorse for production-scale agentic post-training. | [Paper](https://arxiv.org/abs/2603.21383), [Tweet](https://x.com/omarsar0/status/2038015536253272145?s=20) |
| 9) **Workflow Optimization for LLM Agents** - A comprehensive survey from IBM that maps recent methods for designing and optimizing LLM agent workflows, treating them as agentic computation graphs (ACGs). The survey organizes prior work along three dimensions: when structure is determined, what part of the workflow is optimized, and which evaluation signals guide optimization. It distinguishes between reusable workflow templates, run-specific realized graphs, and execution traces, covering methods like AFlow (Monte Carlo Tree Search over operator graphs), Automated Design of Agentic Systems (code-space search via meta-agents), and evolutionary multi-agent system design. A useful reference for teams building production agent systems where wiring decisions between model calls, retrieval, tool use, and verification matter as much as model capability. | [Paper](https://arxiv.org/abs/2603.22386), [Tweet](https://x.com/omarsar0/status/2037536637954212332) |
| 10) **BIGMAS** - Even the best reasoning models hit an accuracy collapse beyond a certain problem complexity. BIGMAS (Brain-Inspired Graph Multi-Agent Systems) organizes specialized LLM agents as nodes in a dynamically constructed directed graph, coordinating exclusively through a centralized shared workspace inspired by global workspace theory from cognitive neuroscience. A GraphDesigner agent analyzes each problem instance and produces a task-specific directed agent graph together with a workspace contract. The framework constructs structurally distinct graphs whose complexity tracks task demands, from compact three-node pipelines for simple arithmetic to nine-node cyclic structures for multi-step planning. BIGMAS consistently improves reasoning performance for both standard LLMs and large reasoning models, outperforming existing multi-agent baselines. | [Paper](https://arxiv.org/abs/2603.15371), [Tweet](https://x.com/dair_ai/status/2033919566053826696) |

## Top AI Papers of the Week (March 9 - March 15) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **OpenDev** - Terminal-native coding agents represent a fundamental shift in how developers interact with AI assistance. OpenDev is an open-source, command-line coding agent that operates where developers already manage source control and deploy environments, offering a comprehensive 81-page technical report on scaffolding, harness design, context engineering, and lessons learned from building production coding agents. <br>● Dual-agent architecture: OpenDev separates planning from execution through a compound AI system with workload-specialized model routing. Work is organized into concurrent sessions, each composed of multiple specialized sub-agents that independently bind to a user-configured LLM, enabling fine-grained model selection for different tasks.  <br>● Adaptive context compaction: Effective autonomous assistance requires highly efficient context management to prevent context bloat and reasoning degradation. OpenDev implements lazy tool discovery and adaptive methods to reduce older observations, keeping the agent’s working memory lean as tasks grow in complexity.  <br>● Automated project memory: The system incorporates automated memory for project-specific knowledge and event-driven reminders to prevent instruction fade-out. This ensures that the agent retains critical project context across sessions without manual intervention.  <br>● Four-layer architecture: The system spans agent reasoning, context engineering, tooling, and persistence layers. This modular design provides a secure, extensible foundation for terminal-first AI assistance that can evolve independently at each layer. | [Paper](https://arxiv.org/abs/2603.05344), [Tweet](https://x.com/omarsar0/status/2030771811705872435) |
| 2) **AutoHarness** - Google DeepMind researchers introduce AutoHarness, a method for automatically synthesizing code harnesses that prevent LLM agents from making illegal actions. The core insight comes from a striking observation: in the Kaggle GameArena chess competition, 78% of Gemini-2.5-Flash losses were attributed to illegal moves, not poor strategy. <br>● Automatic harness synthesis: Rather than building complex rule systems by hand, AutoHarness lets Gemini-2.5-Flash automatically generate a code harness through a small number of iterative refinement rounds using feedback from the game environment. The harness acts as a programmatic constraint layer between the agent and the environment.  <br>● Smaller models beat larger ones: The resulting harness enables the smaller Gemini-2.5-Flash to outperform much larger models including Gemini-2.5-Pro and GPT-5.2-High on 16 TextArena single-player games. This shows that structured code constraints can compensate for raw model capability.  <br>● Complete illegal move prevention: The synthesized harness successfully prevents all illegal moves across 145 different TextArena games, covering both single-player and two-player settings. This transforms a model that previously failed on most turns into a competitive agent.  <br>● Cost-effective scaling: Using a smaller model to synthesize a custom code harness is not only more performant but also more cost-effective than simply deploying a larger model. This reframes the agent improvement problem from model scaling to harness engineering. | [Paper](https://arxiv.org/abs/2603.03329), [Tweet](https://x.com/omarsar0/status/2032110243665088950) |
| 3) **SkillNet** - AI agents repeatedly rediscover solutions across separate scenarios instead of systematically reusing what they have already learned. SkillNet introduces an open infrastructure designed to create, evaluate, and organize AI skills at scale, enabling agents to transition from transient experience to durable mastery. <br>● Unified skill ontology: Skills are structured within a unified ontology that supports creation from heterogeneous sources, including code libraries, prompt templates, and tool compositions. Rich relational connections between skills enable discovery and composition that would be impossible with flat skill stores.  <br>● Multi-dimensional evaluation: Every skill is assessed across five dimensions: Safety, Completeness, Executability, Maintainability, and Cost-awareness. This systematic evaluation ensures that skills entering the repository meet quality thresholds before agents rely on them in production.  <br>● Massive skill repository: SkillNet includes a repository of over 200,000 skills, an interactive platform for skill browsing and management, and a Python toolkit for programmatic access. This scale enables meaningful skill retrieval and composition across diverse task domains.  <br>● Consistent agent improvements: Experimental evaluations on ALFWorld, WebShop, and ScienceWorld demonstrate that SkillNet significantly enhances agent performance, improving average rewards by 40% and reducing execution steps by 30% across multiple backbone models. | [Paper](https://arxiv.org/abs/2603.04448), [Tweet](https://x.com/omarsar0/status/2030692286317961280) |
| 4) **The Spike, the Sparse and the Sink** - Yann LeCun and collaborators at NYU dissect two recurring phenomena in Transformer language models: massive activations, where a small number of tokens exhibit extreme outliers in specific channels, and attention sinks, where certain tokens attract disproportionate attention mass regardless of semantic relevance. The paper reveals that their co-occurrence is largely an architectural artifact. <br>● Distinct operational scopes: Massive activations operate globally, inducing near-constant hidden representations that persist across layers and function as implicit model parameters. Attention sinks operate locally, modulating attention outputs across heads and biasing individual heads toward short-range dependencies.  <br>● Pre-norm as the critical factor: The pre-norm configuration common in modern Transformers is identified as the key architectural element enabling the co-occurrence of these two phenomena. Removing pre-norm causes massive activations and attention sinks to decouple entirely.  <br>● Practical implications for efficiency: Understanding these phenomena has direct consequences for model compression, quantization, and KV-cache optimization. Many efficiency techniques fail silently when they inadvertently disrupt massive activations or attention sinks, and this paper explains why.  <br>● Not functionally necessary: The co-occurrence of spikes and sinks is a design-dependent artifact rather than a fundamental requirement for model performance. This opens the door to architectural modifications that could eliminate these phenomena without sacrificing capability. | [Paper](https://arxiv.org/abs/2603.05498), [Tweet](https://x.com/omarsar0/status/2030403147588604376) |
| 5) **KARL** - Databricks presents KARL, a system for training enterprise search agents via reinforcement learning that achieves state-of-the-art performance across a diverse suite of hard-to-verify agentic search tasks. The work also introduces KARLBench, a new evaluation framework spanning six search domains. <br>● New post-training paradigm (OAPL): KARL concurrently develops OAPL, an iterative large-batch off-policy RL approach. By embracing off-policyness in the design of the objective, it is robust to discrepancies between the trainer and the inference engine without requiring heuristics like clipped importance weighting or data deletion.  <br>● Multi-task heterogeneous training: Rather than optimizing for a single benchmark, KARL trains across heterogeneous search behaviors including constraint-driven entity search, cross-document synthesis, tabular reasoning, entity retrieval, procedural reasoning, and fact aggregation. This produces substantially better generalization than single-benchmark optimization.  <br>● Pareto-optimal performance: Starting from GLM 4.5 Air with varying levels of test-time scaling, KARL is Pareto-optimal on KARLBench when compared to Claude 4.6 and GPT 5.2 across both cost-quality and latency-quality tradeoffs.  <br>● Scalable with test-time compute: KARL-BCP attains 59.6 on BrowseComp-Plus, which further improves to 70.4 with value-guided search. KARL-TREC reaches 85.0 on TREC-Biogen, the second-highest score overall. The system surpasses the strongest closed models given sufficient test-time compute. | [Paper](https://arxiv.org/abs/2603.05218), [Tweet](https://x.com/dair_ai/status/2030996795770433749) |
| 6) **Memex(RL)** - As tasks get longer and more complex, LLM agents lose track of what they have learned, what they have tried, and what still needs to be done. Memex(RL) introduces an indexed experience memory mechanism that scales agent capability on long-horizon tasks without discarding evidence or blowing up the context window. <br>● Indexed experience memory: Rather than lossy compression, Memex maintains a compact working context consisting of concise structured summaries and stable indices while storing full-fidelity underlying interactions in an external experience database. The agent decides what to summarize, what to archive, how to index it, and when to retrieve it.  <br>● RL-optimized memory operations: The MemexRL reinforcement learning framework optimizes both write and read behaviors with reward shaping tailored to indexed memory usage under a context budget. This teaches the agent to manage its own memory strategically rather than relying on fixed heuristics.  <br>● Bounded retrieval complexity: Theoretical analysis demonstrates that Memex can maintain decision quality with bounded retrieval operations while keeping computational load manageable as task history grows. This makes the approach practical for tasks that span hundreds or thousands of steps.  <br>● Smaller context, better results: Empirically, agents trained with MemexRL improve task success rates on challenging long-horizon tasks while using a significantly smaller working context than baseline approaches. Less context, used more intelligently, outperforms brute-force context expansion. | [Paper](https://arxiv.org/abs/2603.04257), [Tweet](https://x.com/omarsar0/status/2031006858971058537) |
| 7) **FlashAttention-4** - FlashAttention-4 co-designs algorithms and kernel pipelines for the B200 and GB200 GPUs, which exhibit fundamentally different performance characteristics due to asymmetric hardware scaling where tensor core throughput doubles while other functional units scale more slowly. <br>● Significant speedups on Blackwell: FlashAttention-4 achieves up to 1.3x speedup over cuDNN 9.13 and 2.7x over Triton on B200 GPUs with BF16, reaching up to 1613 TFLOPs/s at 71% hardware utilization. These gains come from careful co-design rather than algorithmic changes alone.  <br>● Asymmetric scaling solutions: The techniques include redesigned pipelines that exploit fully asynchronous matrix multiply operations and larger tile sizes, software-emulated exponential and conditional softmax rescaling, and leveraging tensor memory to reduce shared memory traffic.  <br>● Python-native implementation: The entire system is implemented in CuTe-DSL embedded in Python, achieving 20-30x faster compile times compared to traditional C++ template-based approaches while maintaining full expressivity. This dramatically lowers the barrier to kernel development.  <br>● Hardware-algorithm co-design: The paper demonstrates that next-generation GPU architectures demand fundamentally new attention kernel designs rather than incremental optimizations of existing ones. Techniques that worked well on Hopper GPUs leave significant performance on the table on Blackwell. | [Paper](https://arxiv.org/abs/2603.05451), [Tweet](https://x.com/dair_ai/status/2030411164060889466) |
| 8) **STRUCTUREDAGENT** - STRUCTUREDAGENT introduces a hierarchical planning framework for long-horizon web tasks using dynamic AND/OR trees. The framework separates planning responsibilities: the system constructs and maintains the planning tree while the LLM is invoked only for local operations like node expansion or repair. A structured memory module tracks candidate solutions to improve constraint satisfaction. Results on WebVoyager, WebArena, and custom shopping benchmarks show improved performance over standard LLM-based web agents, with the added benefit of interpretable hierarchical plans that enable easier debugging and human intervention. | [Paper](https://arxiv.org/abs/2603.05294), [Tweet](https://x.com/omarsar0/status/2030681964664213509) |
| 9) **AgentIR** - Deep research agents generate explicit reasoning before every search call, but existing retrievers completely ignore these rich signals about search intent and problem context. AgentIR introduces reasoning-aware retrieval that jointly embeds the agent’s reasoning trace alongside its query, along with DR-Synth, a data synthesis method for generating training data from standard QA datasets. On BrowseComp-Plus, AgentIR-4B achieves 68% accuracy with Tongyi-DeepResearch compared to 50% with conventional embedding models twice its size and 37% with BM25. | [Paper](https://arxiv.org/abs/2603.04384), [Tweet](https://x.com/dair_ai/status/2031726356292407366) |
| 10) **Think Harder or Know More** - This paper investigates transformer models featuring both adaptive per-layer looping, where each block learns to iterate its hidden state via a learned halting mechanism, and gated memory banks that provide additional learned storage. The key finding is that looping primarily benefits mathematical reasoning while memory banks help recover performance on commonsense tasks. Combining both mechanisms yields a model that outperforms an iso-FLOP baseline with three times the number of layers on math benchmarks. Analysis of model internals reveals layer specialization: early layers loop minimally and access memory sparingly, while later layers do both more heavily. | [Paper](https://arxiv.org/abs/2603.08391), [Tweet](https://x.com/dair_ai/status/2032107624007876781) |

## Top AI Papers of the Week (March 1 - March 8) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **NeuroSkill** - MIT researchers introduce NeuroSkill, a real-time proactive agentic system that models human cognitive and emotional state by integrating Brain-Computer Interface (BCI) signals with foundation EXG models and text embeddings. Unlike reactive agents that wait for explicit commands, NeuroSkill operates proactively, interpreting biophysical and neural signals to anticipate user needs. <br>● Custom agent harness - NeuroLoop: The system runs an agentic flow called NeuroLoop that engages with the user on multiple cognitive and affective levels, including empathy. It processes BCI signals through a foundation EXG model, converts them to state-of-mind descriptions, and uses those descriptions to drive actionable tool calls and protocol execution.  <br>● Fully offline edge deployment: The entire system runs locally on edge devices with no network dependency. This is a significant design choice for both privacy and latency, enabling real-time responsiveness to shifting cognitive states without cloud round-trips.  <br>● Proactive vs reactive interaction: NeuroSkill handles both explicit and implicit requests from the user. By continuously reading brain signals, it can detect confusion, cognitive overload, or emotional shifts and adjust its behavior before the user explicitly asks for help.  <br>● Open-source with ethical licensing: Released under GPLv3 with an ethically aligned AI100 licensing framework for the skill markdown, making the system reproducible and auditable while enforcing responsible use guardrails. | [Paper](https://arxiv.org/abs/2603.03212), [Tweet](https://x.com/omarsar0/status/2029201212596519070) |
| 2) **Bayesian Teaching for LLMs** - Google researchers introduce a method to teach LLMs to reason like Bayesians by fine-tuning on interactions with a Bayesian Assistant that represents optimal probabilistic inference. LLMs normally fall far short of normative Bayesian reasoning, but this training approach dramatically improves their ability to update predictions based on new evidence. <br>● Bayesian Assistant as teacher: The method constructs synthetic training data from interactions between users and an idealized Bayesian Assistant. By exposing the LLM to examples of optimal belief updating, the model learns to approximate Bayesian inference without any architectural changes.  <br>● Generalization to new tasks: The trained models do not just memorize the training distributions. They generalize probabilistic reasoning to entirely new task types, suggesting that Bayesian inference can be instilled as a transferable capability through carefully designed fine-tuning data.  <br>● Closing the gap with normative models: Before training, LLMs show systematic deviations from Bayesian predictions, including base rate neglect and conservatism. After Bayesian teaching, these biases are substantially reduced, bringing model predictions much closer to the normative standard.  <br>● Data quality over model scale: The results reinforce a recurring theme in recent research: carefully curated training data can unlock capabilities that scale alone cannot. A smaller model trained on Bayesian interactions outperforms larger models reasoning from scratch. | [Paper](https://arxiv.org/abs/2503.17523), [Tweet](https://x.com/GoogleResearch/status/2029295018972778883?s=20) |
| 3) **Why LLMs Form Geometric Representations** - LLMs spontaneously form striking geometric structures in their internal representations: calendar months organize into circles, historical years form spirals, and spatial coordinates align to recoverable manifolds. This paper proves these patterns are not the product of deep learning dynamics but emerge directly from symmetries in natural language statistics. <br>● Translation symmetry as the root cause: The frequency with which any two months co-occur in text depends only on the time interval between them, not the months themselves. The authors prove this translation symmetry in co-occurrence statistics is sufficient to force circular geometry in learned representations.  <br>● Analytical derivation of manifold geometry: Rather than just observing geometric structure post-hoc, the paper derives the exact manifold geometry from data statistics. For cyclic concepts like months or days of the week, the proof shows circular representations emerge as the optimal encoding under symmetric co-occurrence distributions.  <br>● Spirals and rippled manifolds for continuums: Representations of continuous concepts like historical years or number lines organize into compact 1D manifolds with characteristic extrinsic curvature. These “rippled” structures are analytically predicted by the framework when the underlying latent variable is non-cyclic.  <br>● Universal origin: The robustness of these geometric representations across different model architectures suggests a universal mechanism. Representational manifolds emerge whenever co-occurrence statistics are controlled by an underlying latent variable, regardless of model size or training details. | [Paper](https://arxiv.org/abs/2602.15029), [Tweet](https://x.com/che_shr_cat/status/2029626128566993201) |
| 4) **Theory of Mind in Multi-Agent LLMs** - This work introduces a multi-agent architecture combining Theory of Mind (ToM), Belief-Desire-Intention (BDI) models, and symbolic solvers for logical verification, evaluating it on resource allocation problems across multiple LLMs. The central finding is counterintuitive: simply adding cognitive mechanisms does not automatically improve coordination. <br>● Integrated cognitive architecture: The system combines ToM for modeling other agents’ mental states, BDI frameworks for structuring internal beliefs, and symbolic solvers for formal logic verification. This layered approach attempts to replicate how humans reason about collaborative partners.  <br>● Model capability matters more than mechanism: The effectiveness of ToM and internal beliefs varies significantly depending on the underlying LLM. Stronger models benefit from cognitive mechanisms, while weaker models can actually be confused by the additional reasoning overhead.  <br>● Symbolic verification as a stabilizer: Integrating symbolic solvers for logical verification helps ground agent decisions in formal constraints. The interplay between symbolic verification and cognitive mechanisms remains largely underexplored across different LLM architectures.  <br>● Practical implications for multi-agent design: For builders designing systems where agents must model each other’s beliefs, the key takeaway is to match cognitive complexity to model capability. Adding ToM to an underpowered model can hurt more than help. | [Paper](https://arxiv.org/abs/2603.00142), [Tweet](https://x.com/omarsar0/status/2028913061260935331) |
| 5) **Numina-Lean-Agent** - Numina-Lean-Agent proposes a paradigm shift in automated theorem proving: instead of building complex, multi-component systems with heavy computational overhead, it directly uses a general coding agent as a formal math reasoner. Combining Claude Code with Numina-Lean-MCP, the system autonomously interacts with the Lean proof assistant while accessing theorem libraries and auxiliary reasoning tools. <br>● General agent over specialized provers: Rather than training task-specific models, the system leverages a general-purpose coding agent. Performance improves simply by upgrading the base model, making the approach accessible and reproducible without expensive retraining pipelines.  <br>● MCP-powered tool integration: The system uses Model Context Protocol for flexible extension, including Lean-LSP-MCP for proof assistant interaction, LeanDex for semantic theorem retrieval, and an informal prover for generating detailed proof strategies.  <br>● State-of-the-art results: Using Claude Opus 4.5 as the base model, Numina-Lean-Agent solves all 12 problems on Putnam 2025, matching the best closed-source systems. It also successfully formalized the Brascamp-Lieb theorem through direct collaboration with mathematicians.  <br>● Open-source release: The full system and all solutions are released on GitHub under Creative Commons BY 4.0, enabling direct reproduction and extension by the research community. | [Paper](https://arxiv.org/abs/2601.14027), [Tweet](https://x.com/omarsar0/status/2028591203579822112) |
| 6) **ParamMem** - Self-reflection enables language agents to iteratively refine solutions, but models tend to generate repetitive reflections that add noise instead of useful signal. ParamMem introduces a parametric memory module that encodes cross-sample reflection patterns into model parameters, enabling diverse reflection generation through temperature-controlled sampling. <br>● Diversity correlates with success: Empirical analysis reveals a strong positive correlation between reflective diversity and task success. The core problem is that standard self-reflection produces near-identical outputs across iterations, limiting the agent’s ability to explore alternative solution paths.  <br>● Three-tier memory architecture: ParamAgent integrates parametric memory (cross-sample patterns encoded in parameters), episodic memory (individual task instances), and cross-sample memory (broader learning patterns). This combination captures both local task context and global reflection strategies.  <br>● Weak-to-strong transfer: ParamMem is sample-efficient and supports transfer across model scales. Reflection patterns learned by smaller models can be applied to larger ones, enabling self-improvement without reliance on stronger external models.  <br>● Consistent benchmark gains: Evaluated on code generation, mathematical reasoning, and multi-hop question answering, ParamMem consistently outperforms state-of-the-art baselines across all three domains. | [Paper](https://arxiv.org/abs/2602.23320), [Tweet](https://x.com/dair_ai/status/2028839081392939071) |
| 7) **Auton Agentic AI Framework** - Snap Research introduces the Auton framework, a declarative architecture for specification, governance, and runtime execution of autonomous agent systems. It addresses a fundamental mismatch: LLMs produce stochastic, unstructured outputs, while backend infrastructure requires deterministic, schema-conformant inputs. <br>● Cognitive Blueprint separation: The framework enforces a strict separation between the Cognitive Blueprint, a declarative, language-agnostic specification of agent identity and capabilities, and the Runtime Engine. This enables cross-language portability, formal auditability, and modular tool integration via Model Context Protocol.  <br>● Formal agent execution model: Agent execution is formalized as an augmented Partially Observable Markov Decision Process with a latent reasoning space. This gives practitioners a rigorous foundation for reasoning about agent behavior, state transitions, and decision boundaries.  <br>● Biologically-inspired memory: The architecture introduces hierarchical memory consolidation inspired by biological episodic memory systems, providing agents with structured long-term retention that mirrors how humans consolidate experiences into lasting knowledge.  <br>● Runtime optimizations: Parallel graph execution, speculative inference, and dynamic context pruning reduce end-to-end latency for multi-step agent workflows. Safety is enforced through a constraint manifold formalism using policy projection rather than post-hoc filtering. | [Paper](https://arxiv.org/abs/2602.23720), [Tweet](https://x.com/dair_ai/status/2028480209033568475) |
| 8) **Reaching Agreement Among LLM Agents** - This paper introduces Aegean, a consensus protocol that frames multi-agent refinement as a distributed consensus problem. Rather than static heuristic workflows with fixed loop limits, Aegean enables early termination when sufficient agents converge, achieving 1.2-20x latency reduction across four mathematical reasoning benchmarks while maintaining answer quality within 2.5%. The consensus-aware serving engine performs incremental quorum detection across concurrent agent executions, cutting wasted compute on stragglers. | [Paper](https://arxiv.org/abs/2512.20184), [Tweet](https://x.com/omarsar0/status/2028823724196343923) |
| 9) **Diagnosing Agent Memory** - This paper introduces a diagnostic framework that separates retrieval failures from utilization failures in LLM agent memory systems. Through a 3x3 factorial study crossing three write strategies with three retrieval methods, the authors find that retrieval is the dominant bottleneck, accounting for 11-46% of errors, while utilization failures remain stable at 4-8% regardless of configuration. Hybrid reranking cuts retrieval failures roughly in half, delivering larger gains than any write strategy optimization. | [Paper](https://arxiv.org/abs/2603.02473), [Tweet](https://x.com/dair_ai/status/2029202969456234562) |
| 10) **Phi-4-reasoning-vision-15B** - Microsoft presents Phi-4-reasoning-vision-15B, a compact open-weight multimodal reasoning model that combines visual understanding with structured reasoning capabilities. Trained on just 200 billion tokens of multimodal data, the model excels at math and science reasoning and UI comprehension while requiring significantly less compute than comparable open-weight VLMs. The key insight is that systematic filtering, error correction, and synthetic augmentation remain the primary levers for model performance, pushing the Pareto frontier of the accuracy-compute tradeoff. | [Paper](https://arxiv.org/abs/2603.03975), [Tweet](https://x.com/omarsar0/status/2029926242640912429) |

## Top AI Papers of the Week (February 23 - March 1) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **Deep-Thinking Tokens** - Google researchers challenge the assumption that longer outputs indicate better reasoning. They introduce deep-thinking tokens, a metric that identifies tokens where internal model predictions shift significantly across layers before stabilizing. Unlike raw token count, which negatively correlates with accuracy (r = -0.59), the deep-thinking ratio shows a robust positive correlation (r = 0.683). <br>● Deep-thinking ratio as a reasoning signal: For each generated token, intermediate-layer distributions are compared to the final-layer distribution using Jensen-Shannon divergence. A token qualifies as deep-thinking if its prediction only stabilizes in the final 15% of layers. This captures genuine computational effort rather than surface-level verbosity.  <br>● Think@n test-time scaling: The authors introduce Think@n, a strategy that prioritizes samples with high deep-thinking ratios. It matches or exceeds standard self-consistency performance while cutting inference costs by approximately 50% through early rejection of unpromising generations based on just 50-token prefixes.  <br>● Benchmark validation: Evaluated across AIME 24/25, HMMT 25, and GPQA-diamond with reasoning models including GPT-OSS, DeepSeek-R1, and Qwen3. The deep-thinking ratio consistently outperforms length-based and confidence-based baselines as a predictor of correctness.  <br>● Practical implications: This reframes how we think about test-time compute. Instead of generating more tokens, we should focus on generating tokens that require deeper internal computation, enabling more efficient and accurate reasoning. | [Paper](https://arxiv.org/abs/2602.13517), [Tweet](https://x.com/omarsar0/status/2025239354327924833) |
| 2) **Codified Context** - Single-file AGENTS.md manifests don’t scale beyond modest codebases. A 1,000-line prototype can be fully described in a single prompt, but a 100,000-line system cannot. This paper presents a three-component codified context infrastructure developed during construction of a 108,000-line C# distributed system, evaluated across 283 development sessions. <br>● Hot-memory constitution: A living document encoding conventions, retrieval hooks, and orchestration protocols that the agent consults at the start of every session. This provides immediate awareness of project standards without requiring the agent to rediscover them through exploration.  <br>● Domain-expert agents: 19 specialized agents, each owning a bounded domain of the codebase with its own context slice. Instead of one generalist agent trying to hold the entire project in context, tasks are routed to the agent with the deepest knowledge of the relevant subsystem.  <br>● Cold-memory knowledge base: 34 on-demand specification documents that agents retrieve only when needed. This tiered approach keeps the active context lean while ensuring detailed specifications are always accessible for complex implementation decisions.  <br>● Session continuity results: Across 283 sessions, the infrastructure demonstrates how context propagates between sessions, preventing the common pattern where agents forget conventions, repeat known mistakes, and lose coherence on long-running projects. | [Paper](https://arxiv.org/abs/2602.20478), [Tweet](https://x.com/omarsar0/status/2027770787659464812) |
| 3) **Discovering Multi-Agent Learning Algorithms with LLMs** - Google DeepMind uses AlphaEvolve, an evolutionary coding agent powered by LLMs, to automatically discover new multi-agent learning algorithms for imperfect-information games. Rather than relying on manual algorithm design, the system navigates vast algorithmic design spaces and discovers non-intuitive mechanisms that outperform state-of-the-art baselines. <br>● VAD-CFR discovery: The system discovers a novel variant of iterative regret minimization featuring volatility-sensitive discounting and consistency-enforced optimism. VAD-CFR outperforms existing baselines like Discounted Predictive CFR+ on standard imperfect-information game benchmarks.  <br>● SHOR-PSRO discovery: A population-based training algorithm variant that introduces a hybrid meta-solver blending Optimistic Regret Matching with temperature-controlled strategy distributions. This automates the transition from diversity exploration to equilibrium convergence.  <br>● LLM-driven algorithmic evolution: AlphaEvolve generates candidate algorithm modifications, evaluates them on game-theoretic benchmarks, and iteratively refines the best variants. The discovered algorithms contain novel design choices that human researchers had not previously considered.  <br>● Broader implications: This demonstrates that LLMs can serve as algorithmic designers, not just code generators. The approach could extend to discovering algorithms in other domains like optimization, scheduling, and resource allocation. | [Paper](https://arxiv.org/abs/2602.16928), [Tweet](https://x.com/omarsar0/status/2026044154040742150) |
| 4) **Evaluating AGENTS.md** - This research evaluates whether AGENTS.md files, the repository-level context files that developers write to help AI coding agents understand their codebases, actually improve agent performance. Testing four coding agents (Claude Code with Sonnet-4.5, Codex with GPT-5.2 and GPT-5.1 mini, and Qwen Code with Qwen3-30b-coder), the findings are counterintuitive. <br>● Context files reduce success rates: Human-written AGENTS.md files provide a modest +4% improvement in some cases, but LLM-generated ones actually hurt performance by -2%. Both consistently increase inference cost by over 20%, making the cost-benefit tradeoff questionable.  <br>● Broader exploration, worse outcomes: Context files cause agents to explore more code paths and consider more files, but this expansive behavior makes tasks harder rather than easier. The additional context introduces noise that dilutes task-relevant information.  <br>● Lean is better: The study recommends that developer-written context files should contain only essential information. Unnecessary requirements, coding style preferences, and broad architectural descriptions complicate agent task completion without improving results.  <br>● Practical guidance: For developers maintaining AGENTS.md files, the key takeaway is to keep them minimal and focused on critical constraints. Information density matters more than comprehensiveness for current coding agents. | [Paper](https://arxiv.org/abs/2602.11988), [Tweet](https://x.com/omarsar0/status/2026306141181898887) |
| 5) **PAHF** - Meta introduces PAHF (Personalized Agents from Human Feedback), a continual agent personalization framework that addresses a critical gap: most AI agents cannot adapt to individual user preferences that evolve over time. PAHF couples explicit per-user memory with both proactive and reactive feedback mechanisms. <br>● Three-step personalization loop: PAHF operates through (1) pre-action clarification to resolve ambiguity before acting, (2) grounding actions in preferences retrieved from persistent memory, and (3) integrating post-action feedback to update memory when preferences drift. This dual-feedback design captures both explicit and implicit signals.  <br>● Continual learning through interaction: Unlike static fine-tuning approaches, PAHF enables agents to learn from live interactions. The explicit memory store allows agents to accumulate and revise user preference profiles without retraining, making personalization practical for production deployments.  <br>● Novel benchmarks: The researchers develop two benchmarks in embodied manipulation and online shopping that specifically measure an agent’s ability to learn initial preferences from scratch and then adapt when those preferences shift over time.  <br>● Strong results: PAHF learns substantially faster and consistently outperforms both no-memory and single-channel baselines. It reduces initial personalization error and enables rapid adaptation to persona shifts, demonstrating that the combination of memory and dual feedback channels is essential. | [Paper](https://arxiv.org/abs/2602.16173), [Tweet](https://x.com/dair_ai/status/2025242624790331520) |
| 6) **Doc-to-LoRA** - Sakana AI introduces Doc-to-LoRA (D2L), a lightweight hypernetwork that meta-learns to compress long documents into LoRA adapters in a single forward pass. Instead of processing long contexts through expensive quadratic attention, D2L converts the document into parameter-space representations that the target LLM can use without re-consuming the original text. <br>● Single-pass context compression: D2L generates LoRA adapters from unseen documents in one forward pass. Once compressed, subsequent queries are handled using only the adapter weights, eliminating the need to re-process the full document and dramatically reducing both inference latency and KV-cache memory demands.  <br>● Beyond native context windows: The method achieves near-perfect zero-shot accuracy on needle-in-a-haystack tasks at sequence lengths exceeding the target LLM’s native context window by over 4x. This suggests that parametric compression can effectively extend context capabilities without architectural changes.  <br>● Real-world QA performance: On practical question-answering datasets, D2L outperforms standard long-context approaches while consuming less memory. The compressed representations retain enough information for accurate retrieval and reasoning across the full document.  <br>● Practical deployment benefits: For applications requiring repeated queries over the same document (customer support, legal analysis, codebase understanding), D2L compresses the document once and amortizes the cost across all subsequent interactions. | [Paper](https://arxiv.org/abs/2602.15902), [Tweet](https://x.com/omarsar0/status/2027385998993420571) |
| 7) **AgentConductor** - AgentConductor introduces a reinforcement learning-enhanced multi-agent system for code generation that dynamically generates interaction topologies based on task characteristics. Rather than using fixed communication patterns between agents, an LLM-based orchestrator adapts the topology to match problem complexity, achieving state-of-the-art accuracy across five code generation datasets. <br>● Task-adapted topologies: The orchestrator constructs density-aware layered directed acyclic graph (DAG) topologies tailored to problem difficulty. Simple problems get sparse topologies with minimal communication overhead, while complex problems get denser multi-agent collaboration.  <br>● Topological density control: A novel density function and difficulty interval partitioning mechanism controls how much agents communicate. This directly addresses the problem of redundant interactions that waste tokens without improving solution quality.  <br>● Strong performance gains: AgentConductor outperforms the strongest baseline by up to 14.6% in pass@1 accuracy with 13% density reduction and 68% token cost reduction. The system achieves better results while using significantly fewer computational resources.  <br>● Execution feedback refinement: Topologies are refined using execution feedback from code tests. When initial solutions fail, the orchestrator adjusts the collaboration structure based on error patterns, enabling adaptive recovery. | [Paper](https://arxiv.org/abs/2602.17100), [Tweet](https://x.com/dair_ai/status/2027030406441341227) |
| 8) **ActionEngine** - Georgia Tech and Microsoft Research introduce ActionEngine, a training-free framework that transforms GUI agents from reactive step-by-step executors into programmatic planners. It builds a state-machine memory through offline exploration, then synthesizes executable Python programs for task completion, achieving 95% success on Reddit tasks from WebArena with on average a single LLM call, reducing costs by 11.8x and latency by 2x compared to vision-only baselines. | [Paper](https://arxiv.org/abs/2602.20502), [Tweet](https://x.com/dair_ai/status/2026678090815123594) |
| 9) **CoT Faithfulness via REMUL** - Researchers propose REMUL, a training approach for making chain-of-thought reasoning more faithful and monitorable. A speaker model generates reasoning traces that multiple listener models attempt to follow and complete, using RL to reward reasoning that is understandable to other models. Tested across BIG-Bench Extra Hard, MuSR, ZebraLogicBench, and FOLIO, REMUL improves three faithfulness metrics while also boosting overall accuracy, producing shorter and more direct reasoning chains. | [Paper](https://arxiv.org/abs/2602.16154), [Tweet](https://x.com/dair_ai/status/2026043400861122709) |
| 10) **Learning to Rewrite Tool Descriptions** - Intuit AI Research addresses a bottleneck in LLM-agent tool use: tool descriptions are written for humans, not agents. They introduce Trace-Free+, a curriculum learning framework that optimizes tool descriptions without relying on execution traces. The approach delivers consistent gains on unseen tools, strong cross-domain generalization, and robustness as the number of candidate tools scales to over 100, demonstrating that improving tool interfaces is a practical complement to agent fine-tuning. | [Paper](https://arxiv.org/abs/2602.20426), [Tweet](https://x.com/omarsar0/status/2026676835539628465) |

## Top AI Papers of the Week (February 16 - February 22) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **Intelligent AI Delegation** - Google DeepMind introduces a comprehensive framework for intelligent AI delegation that goes beyond simple task assignment. The framework models delegation as a sequence of decisions: whether to delegate, how to instruct, and how to verify and integrate AI outputs, addressing the gap between what AI agents can do and how humans should interact with them. <br>● Adaptive delegation structure: The framework treats delegation as a dynamic process involving task allocation, transfer of authority, responsibility, and accountability. Rather than static heuristics, it enables real-time adaptation to environmental shifts and resilient failure management across both human and AI delegators.  <br>● Trust calibration mechanisms: Introduces formal trust models that account for capability uncertainty, task complexity, and historical performance. This prevents both over-delegation (assigning tasks beyond agent capability) and under-delegation (failing to leverage available AI capacity).  <br>● Verification and integration: Defines structured approaches for validating AI outputs before integration, including confidence-aware acceptance criteria and fallback protocols. This is critical for production deployments where blind trust in agent outputs creates compounding errors.  <br>● Multi-agent delegation networks: Extends the framework to scenarios where AI agents delegate to other AI agents, creating delegation chains that require accountability tracking and authority propagation rules across the network. | [Paper](https://arxiv.org/abs/2602.11865), [Tweet](https://x.com/omarsar0/status/2023146815789597015) |
| 2) **Emergent Socialization in AI Agent Society** - A study on Moltbook, a social network with no humans where all participants are LLM-driven agents, challenges the assumption that scale and interaction density alone produce meaningful social dynamics. The researchers find that while global semantic content stabilizes quickly, individual agents maintain diversity without converging, displaying strong individual inertia and minimal adaptive response to interaction partners. <br>● Moltbook as a natural laboratory: Moltbook is the largest persistent, publicly accessible AI-only social platform with millions of LLM-driven agents interacting through posts, comments, and voting. This provides an unprecedented real-world testbed for studying emergent collective behavior without human intervention.  <br>● Socialization measurement framework: The paper introduces metrics for semantic stabilization, lexical change, individual consistency, influence duration, and group consensus formation. These go beyond surface-level activity metrics to measure whether genuine social structures are forming.  <br>● No emergent socialization: Despite massive scale and dense interactions, agents fail to develop stable social structures. They do not adapt to each other or form consensus, suggesting that current LLM architectures lack the mechanisms needed for genuine social learning.  <br>● Shared memory as a prerequisite: The study concludes that shared memory is essential for developing stable social structures. Without persistent memory that allows agents to build on prior interactions, social dynamics remain superficial regardless of population size or interaction frequency. | [Paper](https://arxiv.org/abs/2602.14299), [Tweet](https://x.com/omarsar0/status/2023766916473733394) |
| 3) **Lossless Context Management (LCM)** - Lossless Context Management (LCM) is a deterministic architecture for LLM memory that outperforms Claude Code on long-context tasks. Benchmarked on the OOLONG eval using Opus 4.6, the LCM-augmented coding agent Volt achieves higher scores than Claude Code at every context length between 32K and 1M tokens. LCM extends the recursive paradigm pioneered by Recursive Language Models (RLMs) with two engine-managed mechanisms. <br>● Recursive context compression: As the active context window fills, older messages are compacted into a hierarchical summary DAG while retaining lossless pointers to every original message. This trades flexibility for termination guarantees and zero-cost continuity on short tasks.  <br>● Recursive task partitioning: Engine-managed parallel primitives like LLM-Map replace model-written loops, analogous to the move from GOTO to structured control flow. This ensures deterministic execution and lossless retrievability of all prior states.  <br>● Three-level escalation: LCM reduces context overflow via a structured fallback: summary nodes for older messages, compact file references for large inputs, and a guaranteed convergence mechanism that prevents runaway context growth.  <br>● Outperforms Claude Code: On OOLONG, Volt with LCM achieves +29.2 average improvement over raw Opus 4.6, compared to +24.7 for Claude Code. The advantage is largest at 1M tokens (+51.3 vs +47.0), demonstrating that deterministic context management scales better than native file-system access at extreme lengths. | [Paper](https://papers.voltropy.com/LCM), [Tweet](https://x.com/dair_ai/status/2023765147970662761) |
| 4) **GLM-5** - GLM-5 is a foundation model from Zhipu AI designed to transition from vibe coding to agentic engineering. The model introduces novel asynchronous agent RL algorithms that separate generation from training for improved efficiency, and uses DSA technology to reduce computational requirements while preserving long-context understanding. <br>● Asynchronous agent RL: The training infrastructure decouples trajectory generation from policy optimization, enabling parallel scaling of both components. This addresses a key bottleneck in agent RL where sequential generate-train loops limit throughput and experimentation speed.  <br>● Agentic engineering focus: GLM-5 targets end-to-end software engineering tasks rather than isolated code generation. The model handles project-level context, multi-file edits, and iterative development cycles that reflect real production workflows.  <br>● DSA compression: The model’s Distributed Sparse Attention mechanism reduces computational overhead for long-context processing without quality degradation. This allows the model to maintain full project-level context during extended development sessions.  <br>● Strong benchmark results: GLM-5 demonstrates exceptional performance on real-world software engineering projects, surpassing earlier systems on end-to-end development tasks, including specification understanding, implementation, testing, and debugging. | [Paper](https://arxiv.org/abs/2602.15763), [Tweet](https://x.com/omarsar0/status/2024122246688878644) |
| 5) **MemoryArena** - MemoryArena introduces a benchmark for evaluating how agents utilize memory across multiple interconnected sessions. The key finding is that scoring well on memory recall does not mean an agent can actually use that memory to take correct actions across sessions. Models with near-saturated performance on existing benchmarks like LoCoMo perform poorly in agentic multi-session settings. <br>● Agentic memory evaluation: Unlike standard memory benchmarks that test recall in isolation, MemoryArena evaluates whether agents can retrieve and apply relevant past experience to make correct decisions in new contexts. This exposes a gap between retrieval accuracy and actionable memory use.  <br>● Interdependent multi-session tasks: The benchmark spans web navigation, constrained planning, information retrieval, and logical reasoning, where decisions in one session depend on information gathered in previous sessions. This reflects real-world agent deployments where sessions are not independent.  <br>● Exposing evaluation blind spots: Agents achieving near-perfect scores on LoCoMo and other long-context benchmarks show significant performance drops on MemoryArena. This suggests current evaluations overestimate agent memory capabilities by testing retrieval without testing downstream decision quality.  <br>● Practical implications: For developers building persistent agents, MemoryArena provides a more realistic assessment of whether memory systems actually improve task completion rather than just information access. | [Paper](https://arxiv.org/abs/2602.16313), [Tweet](https://x.com/dair_ai/status/2024491176259363013) |
| 6) **MAPLE** - MAPLE proposes separating memory, learning, and personalization into specialized sub-agents rather than treating them as a unified capability. The framework achieves a 14.6% improvement in personalization scores over stateless baselines and increases trait incorporation from 45% to 75%, validated through the MAPLE-Personas benchmark. <br>● Sub-agent decomposition: Memory handles storage and retrieval infrastructure, Learning extracts intelligence from accumulated interactions asynchronously, and Personalization applies learned knowledge in real-time within finite context budgets. Each operates at different timescales with distinct objectives.  <br>● Asynchronous learning: The Learning sub-agent processes interaction history offline, distilling patterns and preferences without consuming real-time context. This avoids the common problem of memory systems that flood the active context window with raw history.  <br>● Context-budget-aware personalization: The Personalization sub-agent selects which learned knowledge to inject based on available context budget and current task relevance. This prevents context dilution while ensuring the most impactful personalizations are always applied.  <br>● Benchmark validation: The MAPLE-Personas benchmark specifically evaluates whether agents can genuinely adapt to individual users over time, measuring trait incorporation and behavioral consistency across extended interaction sequences. | [Paper](https://arxiv.org/abs/2602.13258), [Tweet](https://x.com/dair_ai/status/2024117711253700637) |
| 7) **SkillsBench** - SkillsBench evaluates whether LLM agents can generate their own procedural knowledge across 86 tasks spanning 11 domains, with curated Skills and deterministic verifiers. Testing 7 agent-model configurations over 7,308 trajectories, the benchmark reveals a critical gap: agents benefit enormously from consuming procedural knowledge but cannot reliably author it themselves. <br>● Curated skills boost performance significantly: Providing curated Skills raises the average pass rate by 16.2 percentage points, with effects varying dramatically by domain, from +4.5pp in Software Engineering to +51.9pp in Healthcare. This shows that skill quality and domain match matter more than having skills at all.  <br>● Self-generated skills provide no benefit: On average, models that generate their own procedural knowledge show no improvement over having no skills. This finding is critical for self-improving agent architectures that assume models can bootstrap their own capabilities.  <br>● Focused beats comprehensive: Skills with 2-3 focused modules outperform comprehensive documentation. This suggests that retrieval precision matters more than coverage when augmenting agents with procedural knowledge.  <br>● Smaller models close the gap: Smaller models augmented with well-curated skills can match the performance of larger models operating without skill augmentation. This has direct cost implications for production agent deployments. | [Paper](https://arxiv.org/abs/2602.12670), [Tweet](https://x.com/omarsar0/status/2023511466759094630) |
| 8) **LongCLI-Bench** - LongCLI-Bench benchmarks how well AI agents handle complex, extended tasks through command-line interfaces. Across 20 demanding tasks spanning initial development, feature expansion, error resolution, and code optimization, leading agents succeed less than 20% of the time. The study finds that most failures occur early in task execution, and human-agent collaboration through plan injection and interactive guidance yields significantly greater improvements than automated self-correction alone. | [Paper](https://arxiv.org/abs/2602.14337), [Tweet](https://x.com/omarsar0/status/2024115697702625597) |
| 9) **CogRouter** - CogRouter enables adaptive reasoning depth for LLM agents by dynamically selecting from four hierarchical cognitive levels at each step, from instinctive responses to strategic planning. Using confidence-aware advantage reweighting during training, Qwen2.5-7B with CogRouter achieves 82.3% success rate on agentic benchmarks, substantially outperforming larger models while consuming fewer tokens by skipping heavy reasoning on routine steps. | [Paper](https://arxiv.org/abs/2602.12662), [Tweet](https://x.com/omarsar0/status/2023405531835277504) |
| 10) **Team of Thoughts** - Team of Thoughts presents a multi-agent framework for efficient test-time scaling through orchestrated tool calling. The system uses an orchestrator tool design where agents with different capabilities are coordinated by a calibrated orchestrator. With self-assessment for tool agents and orchestrator calibration for identifying superior coordination models, Team of Thoughts achieves 96.67% on AIME24 and 72.53% on LiveCodeBench, substantially exceeding homogeneous baselines. | [Paper](https://arxiv.org/abs/2602.16485), [Tweet](https://x.com/omarsar0/status/2024490165725737077) |

## Top AI Papers of the Week (February 9 - February 15) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **ALMA** - ALMA (Automated meta-Learning of Memory designs for Agentic systems) from Jeff Clune’s group introduces a Meta Agent that automatically discovers memory designs for agentic systems through open-ended exploration in code space. Instead of relying on hand-engineered memory modules, ALMA searches over database schemas, retrieval mechanisms, and update strategies expressed as executable code, consistently outperforming all human-designed memory baselines across four sequential decision-making benchmarks. <br>● Open-ended code search: A Meta Agent samples previously explored memory designs from an archive, reflects on their code and evaluation logs, proposes new designs, and implements them as executable code. This gives ALMA the theoretical potential to discover arbitrary memory architectures, from graph databases to strategy libraries, unconstrained by human design intuitions.  <br>● Domain-adaptive memory discovery: ALMA discovers fundamentally different memory structures for different domains: affordance graphs for ALFWorld, task signature databases for TextWorld, strategy libraries with rule prediction for Baba Is AI, and risk-interaction schemas for MiniHack. This specialization emerges automatically from the search process.  <br>● Consistent gains over human baselines: Learned memory designs achieve 12.3% average success rate with GPT-5-nano (vs 8.6% for the best human baseline) and 53.9% with GPT-5-mini (vs 48.6%). The designs also scale better with more collected experience and transfer robustly across different foundation models.  <br>● Toward self-improving agentic systems: ALMA represents a step toward AI systems that learn to be continual learners. The progressive discovery process shows that moderate-performing designs serve as stepping stones toward optimal solutions, with the archive enabling cumulative innovation across exploration iterations. | [Paper](https://arxiv.org/abs/2602.07755), [Tweet](https://x.com/jeffclune/status/2021242681826095179) |
| 2) **LLaDA 2.1** - Ant Group releases LLaDA 2.1, a major upgrade to discrete diffusion language models that breaks the speed-quality trade-off through Token-to-Token (T2T) editing. By weaving token editing into the conventional Mask-to-Token decoding scheme, LLaDA 2.1 introduces two configurable modes: Speedy Mode for aggressive throughput and Quality Mode for benchmark-leading accuracy. The release also includes the first large-scale RL framework for diffusion LLMs. <br>● Editable state evolution: Unlike standard diffusion models that only unmask tokens, LLaDA 2.1 can also edit already-generated tokens. This dual action space (unmasking + correction) lets the model aggressively draft with low-confidence thresholds and then refine errors in subsequent passes, fundamentally changing the speed-quality trade-off.  <br>● Two operating modes: Speedy Mode lowers the mask-to-token threshold for maximum throughput, relying on T2T passes to fix errors. Quality Mode uses conservative thresholds for superior benchmark scores. This gives practitioners a configurable knob between speed and accuracy without swapping models.  <br>● Extreme decoding speed: LLaDA 2.1-Flash (100B) hits 892 tokens per second on HumanEval+ and 801 TPS on BigCodeBench. The Mini variant (16B) reaches a peak of 1,587 TPS. These speeds dramatically outpace autoregressive models of comparable quality.  <br>● First RL for diffusion LLMs: The paper introduces EBPO (Evidence-Based Policy Optimization), an RL framework that uses block-causal masking and parallel likelihood estimation to enable stable policy optimization at scale for diffusion models. RL training sharpens reasoning and instruction-following across 33 benchmarks. | [Paper](https://arxiv.org/abs/2602.08676), [Tweet](https://x.com/omarsar0/status/2021582697013838150) |
| 3) **SkillRL** - SkillRL introduces a recursive skill-augmented RL framework that bridges the gap between raw experience and policy improvement through automatic skill discovery. Instead of storing noisy raw trajectories, SkillRL distills experience into reusable high-level behavioral patterns and evolves them alongside the agent policy during training. <br>● Hierarchical skill library (SkillBank): An experience-based distillation mechanism extracts reusable behavioral patterns from raw trajectories and organizes them into a hierarchical skill library. This dramatically reduces the token footprint while preserving the reasoning utility needed for complex multi-step tasks.  <br>● Adaptive skill retrieval: A dual retrieval strategy combines general heuristics with task-specific skills, selecting the most relevant behavioral patterns based on the current task context. This enables the agent to leverage accumulated knowledge without being overwhelmed by irrelevant experience.  <br>● Recursive co-evolution: The skill library and agent policy evolve together during RL training. As the agent encounters harder tasks, new skills are extracted, and existing ones are refined, creating a virtuous cycle where better skills enable better performance, which generates better training data for skill extraction.  <br>● Strong empirical results: SkillRL achieves state-of-the-art performance with 89.9% success rate on ALFWorld, 72.7% on WebShop, and an average of 47.1% on search-augmented QA tasks, outperforming strong baselines by over 15.3% while maintaining robustness as task complexity increases. | [Paper](https://arxiv.org/abs/2602.08234), [Tweet](https://x.com/HuaxiuYaoML/status/2021269712361918516) |
| 4) **InftyThink+** - InftyThink+ is an end-to-end RL framework for infinite-horizon reasoning that optimizes the entire iterative reasoning trajectory. Standard long chain-of-thought suffers from quadratic cost, context length limits, and lost-in-the-middle degradation. InftyThink+ addresses all three by letting models autonomously decide when to summarize, what to preserve, and how to resume, trained through trajectory-level reinforcement learning. <br>● Iterative reasoning with learned boundaries: Instead of generating one continuous chain-of-thought, InftyThink+ decomposes reasoning into multiple iterations connected by self-generated summaries. The model learns to control iteration boundaries, deciding when to compress and continue rather than following fixed heuristics or chunk sizes.  <br>● Two-stage training recipe: A supervised cold-start teaches the InftyThink format (special tokens for summary and history), then trajectory-level GRPO optimizes the full multi-iteration rollout. Advantages are shared across all iterations within a trajectory, so early high-quality summaries that enable correct later reasoning receive a positive gradient signal.  <br>● 21% accuracy gain on AIME24: On DeepSeek-R1-Distill-Qwen-1.5B, InftyThink+ with RL improves accuracy from 29.5% to 50.9% on AIME24, a 21-point jump that substantially outperforms vanilla long-CoT RL (38.8%). Results generalize to out-of-distribution benchmarks, including GPQA Diamond and AIME25.  <br>● Faster inference, faster training: By bounding context length per iteration, InftyThink+ reduces inference latency compared to vanilla reasoning while achieving higher accuracy. Adding an efficiency reward further cuts token usage by 50% with only a modest accuracy trade-off, demonstrating a controllable speed-accuracy knob. | [Paper](https://arxiv.org/abs/2602.06960), [Tweet](https://x.com/dair_ai/status/2020997904731983882) |
| 5) **Agyn** - Agyn is a fully automated multi-agent system that models software engineering as an organizational process rather than a monolithic code generation task. Built on an open-source platform for configuring agent teams, the system assigns specialized agents to distinct roles and follows a structured development methodology - all without human intervention. Notably, Agyn was designed for real production use and was not tuned for the SWE-bench. <br>● Team-based architecture: Four specialized agents (manager, researcher, engineer, reviewer) operate with distinct responsibilities, tools, and model configurations. The manager coordinates using a high-level methodology inspired by real development practice, while the engineer and reviewer work through GitHub-native pull requests and inline code reviews.  <br>● Role-specific model routing: Reasoning-heavy agents like the manager and researcher use larger general-purpose models, while implementation agents use smaller, code-specialized models. This mirrors real team structure, where different roles need different capabilities, and reduces overall cost without sacrificing quality.  <br>● Dynamic workflow, not a fixed pipeline: Unlike prior multi-agent SWE systems that encode a predetermined number of stages, Agyn’s coordination evolves dynamically. The manager decides when additional research, specification refinement, implementation, or review cycles are needed based on intermediate outcomes, enabling flexible iteration.  <br>● Strong benchmark performance without tuning: Agyn resolves 72.2% of tasks on SWE-bench 500, outperforming single-agent baselines by 7.4% under comparable model configurations. The key insight is that organizational design and agent infrastructure may matter as much as model improvements for autonomous software engineering. | [Paper](https://arxiv.org/abs/2602.01465), [Tweet](https://x.com/omarsar0/status/2021267975786070509) |
| 6) **EchoJEPA** - EchoJEPA is a latent predictive foundation model for echocardiography trained on 18 million echocardiograms from 300,000 patients. By learning to predict in latent space rather than pixel space, the model separates clinically meaningful anatomical signals from ultrasound noise and artifacts, producing representations that dramatically outperform existing approaches on cardiac assessment tasks. <br>● Massive scale and latent prediction: Trained on 18 million echocardiograms using a JEPA-style objective that predicts masked spatiotemporal regions in latent space. This approach learns to ignore speckle noise and acoustic artifacts that plague pixel-level methods, producing representations focused on anatomically meaningful features.  <br>● Strong improvements on clinical tasks: EchoJEPA improves left ventricular ejection fraction estimation by approximately 20% and right ventricular systolic pressure estimation by approximately 17% over leading baselines. For view classification, it reaches 79% accuracy using only 1% of labeled data, while the best baseline achieves just 42% with the full labeled dataset.  <br>● Exceptional robustness: Under acoustic perturbations that degrade competitor models by 17%, EchoJEPA degrades only 2%. This robustness extends to population shift: zero-shot performance on pediatric patients exceeds fully fine-tuned baseline models, demonstrating genuine generalization rather than memorization.  <br>● Clinical foundation model potential: The combination of scale, label efficiency, and robustness across patient populations positions EchoJEPA as a practical foundation for clinical echocardiography applications where labeled data is scarce and acoustic conditions vary widely. | [Paper](https://arxiv.org/abs/2602.02603), [Tweet](https://x.com/alifmunim/status/2019863775575482703) |
| 7) **AdaptEvolve** - AdaptEvolve tackles a key efficiency bottleneck in evolutionary agentic systems: the repeated invocation of large LLMs during iterative refinement loops. The method uses intrinsic generation confidence to dynamically select which model to invoke at each step, routing easy sub-problems to smaller models and reserving expensive frontier models for genuinely hard decisions. <br>● Confidence-driven model routing: Instead of static heuristics or external controllers, AdaptEvolve monitors real-time generation confidence scores to estimate task solvability at each evolutionary step. When the smaller model is confident, it proceeds without escalation; when uncertainty is high, the system routes to a larger, more capable model.  <br>● Favorable cost-accuracy trade-off: Across benchmarks, AdaptEvolve cuts inference costs by approximately 38% while retaining roughly 97.5% of the upper-bound accuracy achieved by always using the largest model. This creates a Pareto-optimal frontier that static single-model or naive cascade approaches cannot match.  <br>● Practical for deployed agent loops: Evolutionary and iterative refinement workflows often require dozens of LLM calls per task. Reducing per-call cost by nearly 40% without meaningful accuracy loss makes these workflows viable for production deployment, where cost compounds rapidly.  <br>● Generalizable routing signal: The confidence-based selection mechanism is model-agnostic and does not require task-specific tuning, making it applicable across different evolutionary agent architectures and domain-specific refinement pipelines. | [Paper](https://arxiv.org/abs/2602.11931), [Tweet](https://x.com/dair_ai/status/2022684265079795962) |
| 8) **Gaia2** - Meta FAIR introduces Gaia2, a next-generation agent benchmark where environments change independently of agent actions, forcing agents to handle temporal pressure, uncertainty, and multi-agent coordination. GPT-5 leads at 42% pass@1 but struggles with time-constrained tasks, while Kimi-K2 leads open-source models at 21%. Built on the open-source Agents Research Environments (ARE) platform with action-level verifiers, Gaia2 represents a paradigm shift from static benchmarks to dynamic evaluation of agentic capabilities. | [Paper](https://arxiv.org/abs/2602.11964) |
| 9) **AgentArk** - AgentArk distills multi-agent debate dynamics into a single LLM, transferring the reasoning and self-correction abilities of multi-agent systems into one model at training time. Three hierarchical distillation strategies (reasoning-enhanced SFT, trajectory-based augmentation, and process-aware distillation with a process reward model) yield an average 4.8% improvement over single-agent baselines across math and reasoning benchmarks, approaching full multi-agent performance at a fraction of the inference cost. Cross-family distillation (e.g., Qwen3-32B to LLaMA-3-8B) produces the largest gains, suggesting heterogeneous architectures benefit most from transferred reasoning signals. | [Paper](https://arxiv.org/abs/2602.03955), [Tweet](https://x.com/dair_ai/status/2020889229128270294) |
| 10) **AgentSkiller** - AgentSkiller scales generalist agent intelligence through semantically integrated cross-domain data synthesis, producing 11K high-quality synthetic trajectories across diverse tool-use scenarios. The resulting 14B model beats GPT-o3 on tau2-bench (79.1% vs 68.4%), and even the 4B variant outperforms 70B and 235B models, demonstrating that data quality and semantic integration matter more than parameter count for building strong tool-use agents. | [Paper](https://arxiv.org/abs/2602.09372), [Tweet](https://x.com/dair_ai/status/2021620772817834014) |

## Top AI Papers of the Week (February 2 - February 8) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **Semi-Autonomous Mathematics Discovery with Gemini** - This paper from Google DeepMind presents a case study in semi-autonomous mathematics discovery using Aletheia, a specialized math research agent built on Gemini Deep Think. The team systematically evaluated 700 open conjectures from Bloom’s Erdos Problems database, combining AI-driven natural language verification with human expert evaluation, and addressed 13 previously open problems. <br>● Hybrid methodology: Aletheia was deployed on all 700 open Erdos problems, producing 212 candidate solutions. After initial human grading, 63 were technically correct, but only 13 (6.5%) meaningfully addressed the intended problem statement, revealing how challenging accurate mathematical reasoning remains for AI.  <br>● Four categories of results: The 13 meaningful solutions fell into autonomous resolution (2 problems solved with novel arguments), partial AI solutions (2 multi-part problems partially solved), independent rediscovery (4 problems where solutions already existed in the literature), and literature identification (5 problems already solved but not recorded as such).  <br>● Subconscious plagiarism risk: A key finding is that AI models can reproduce solutions from the literature without attribution, raising concerns about novelty claims. The authors found that for all AI-generated solutions not yet located in the literature, it is plausible that they were previously discovered by humans but never published.  <br>● Challenges at scale: The most arduous step was not verifying correctness but determining whether solutions already existed in prior work. Many technically correct solutions were mathematically vacuous due to misinterpreted problem statements or notational ambiguity.  <br>● Tempered expectations: The authors caution against overexcitement about mathematical significance, noting that most resolved problems could have been dispatched by the right human expert. However, AI shows potential to accelerate attention-bottlenecked aspects of mathematical discovery. | [Paper](https://arxiv.org/abs/2601.22401), [Tweet](https://x.com/quocleix/status/2018402933193539735) |
| 2) **TinyLoRA** - This paper from Meta FAIR asks how small a LoRA adapter can get and still teach a model to reason. The answer: remarkably small. The authors propose TinyLoRA, a method that scales low-rank adapters down to as few as one trainable parameter by projecting through fixed random tensors and sharing weights across all modules. The key insight is that RL makes fundamentally more information-dense updates than SFT, enabling effective learning with orders of magnitude fewer parameters. <br>● 91% accuracy with 13 parameters: Using TinyLoRA with GRPO on GSM8K, Qwen2.5-7B-Instruct reaches 91% accuracy while training just 13 parameters (26 bytes in bf16). This recovers 95% of the full finetuning performance improvement, and even a single trained parameter yields a measurable 4% accuracy gain.  <br>● RL vastly outperforms SFT at low parameter counts: At 13 parameters, RL scores 91% while SFT scores only 83% on GSM8K. The gap widens further below 100 parameters. The paper explains this through signal separation: RL’s reward signal cleanly isolates task-relevant features from noise, while SFT must absorb entire demonstrations, including irrelevant details, requiring far more capacity.  <br>● TinyLoRA method: Builds on LoRA-XS by replacing the trainable rotation matrix with a low-dimensional vector projected through fixed random tensors, and shares this vector across all adapted modules via weight tying. This reduces the minimum trainable parameter count from hundreds (LoRA-XS) down to one.  <br>● Scales across model sizes and harder benchmarks: On six difficult math benchmarks (MATH500, Minerva Math, OlympiadBench, AIME24, AMC23), finetuning Qwen2.5-7B with just 196 parameters retains 87% of the absolute performance improvement. Larger models need fewer parameters to reach the same performance threshold, suggesting trillion-scale models may be trainable with a handful of parameters.  <br>● Practical implications for personalization: Updates under 1KB in total size open new possibilities for efficient distributed training, mass personalization (10x more LoRAs served concurrently with 10x smaller adapters), and reduced forgetting since tiny updates preserve more of the base model’s knowledge. | [Paper](https://arxiv.org/abs/2602.04118), [Tweet](https://x.com/jxmnop/status/2019251724020772933) |
| 3) **xMemory** - xMemory argues that standard RAG retrieval is a poor fit for agent memory because the evidence source is a bounded, coherent dialogue stream where candidate spans are highly correlated near-duplicates. Fixed top-k similarity retrieval collapses into a single dense region, returning redundant context, while post-hoc pruning can break temporally linked evidence chains. xMemory replaces this with hierarchical memory construction and structure-aware top-down retrieval. <br>● Four-level memory hierarchy: Raw messages are grouped into episodes (contiguous dialogue blocks), which are distilled into semantic nodes (reusable facts), which are organized under themes. A sparsity-semantics guidance objective balances theme sizes during construction via split and merge operations, preventing both overly large themes that cause retrieval collapse and overly fragmented ones that weaken evidence coverage.  <br>● Two-stage top-down retrieval: Stage I selects a compact, diverse set of relevant themes and semantic nodes using a greedy coverage-relevance procedure on a kNN graph. Stage II then adaptively expands to episodes and raw messages only when the added detail reduces the reader LLM’s uncertainty, controlled by an early stopping mechanism.  <br>● Evidence density over retrieval volume: Analysis shows xMemory retrieves substantially more evidence-dense contexts (higher 2-hit and multi-hit proportions) than both Naive RAG and RAG with pruning. It covers all answer content with fewer blocks (5.66 vs 10.81) and roughly half the token cost (975 vs 1,979 tokens).  <br>● Consistent gains across backbones: On LoCoMo and PerLTQA benchmarks, xMemory achieves the best average performance across Qwen3-8B, Llama-3.1-8B-Instruct, and GPT-5 nano, outperforming five baselines, including Naive RAG, A-Mem, MemoryOS, Nemori, and LightMem while using fewer tokens per query.  <br>● Retroactive restructuring: Unlike static memory stores, xMemory dynamically reassigns semantic nodes to different themes as new interactions arrive, with split and merge operations updating the high-level structure over time. Enabling this restructuring substantially improves downstream QA accuracy compared to frozen hierarchies. | [Paper](https://arxiv.org/abs/2602.02007), [Tweet](https://x.com/dair_ai/status/2018765444702982395) |
| 4) **SALE** - This paper from Meta shows that small agents match large ones on simple tasks but fall sharply behind as complexity grows, with the cheapest agent reaching only about 21% of the largest agent’s accuracy on the hardest problems. To address this, the authors introduce SALE (Strategy Auctions for Workload Efficiency), a marketplace-inspired framework where heterogeneous agents bid with strategic plans, are scored on cost-value trade-offs, and refine their bids using shared auction memory. <br>● Small agents don’t scale with complexity: On deep search and coding tasks graded by human solution time, the 4B agent achieves approximately 87% of the 32B agent’s accuracy on simple tasks but drops to roughly 21% on the most complex ones. This confirms that model size should be treated as a per-task routing decision, not a global choice.  <br>● Auction-based routing mechanism: Each agent proposes a short strategic plan as its bid. A jury of all agents scores each plan’s value via peer assessment, while cost is estimated from plan length and per-token price. The agent with the best cost-minus-value trade-off wins and executes its strategy.  <br>● Memory-driven self-improvement: After each auction, all bids (winning and losing) are stored in a shared memory bank. Cheaper agents that lost can retrieve similar past tasks, learn from winning strategies via contrastive prompting, and submit refined bids - progressively taking on more work over time, similar to how freelancers upskill in a marketplace.  <br>● Beats the largest agent at lower cost: SALE consistently improves upon the best single agent’s accuracy by 2.7-3.8 points on the hardest tasks while reducing reliance on the 32B model by 53% and cutting overall cost by 35%. It also outperforms four established routers (WTP, CARROT, TO-Router, FrugalGPT) that either underperform the largest agent or fail to reduce cost.  <br>● Complementary failure modes: Analysis reveals that large agents tend to over-engineer and skip tool use, while small agents favor simpler, tool-heavy strategies. SALE exploits this complementarity at bid time, routing tasks to whichever approach fits best without needing to execute full trajectories first. | [Paper](https://arxiv.org/abs/2602.02751), [Tweet](https://x.com/omarsar0/status/2019414476244807892) |
| 5) **InfMem** - InfMem is a cognitive agent for ultra-long document QA that uses System-2-style control to actively manage bounded memory. Instead of passively compressing each chunk as it streams in, InfMem runs a PreThink-Retrieve-Write loop that monitors evidence sufficiency, fetches missing facts from anywhere in the document, and compresses everything into a fixed-size memory - then stops early once it has enough. <br>● PreThink-Retrieve-Write protocol: At each step, a PreThink controller checks whether the current memory can already answer the question. If not, it generates a targeted retrieval query and specifies how many passages to fetch. Retrieve then pulls fine-grained paragraphs from anywhere in the document (not just nearby chunks), and Write jointly compresses the new evidence with existing memory under a fixed token budget.  <br>● Adaptive early stopping: Once the agent determines its memory is sufficient, it terminates the loop immediately rather than processing remaining chunks. This cuts inference time by up to 5.1x on 1M-token documents while preserving or improving accuracy.  <br>● SFT-to-RL training recipe: A two-stage pipeline first distills protocol-valid trajectories from a strong teacher (Qwen3-32B) via supervised fine-tuning, then applies GRPO with verifier-based rewards to align retrieval, writing, and stopping decisions with end-task correctness. RL adds an early-stop shaping reward that penalizes redundant retrieval after the memory becomes sufficient.  <br>● Strong gains over MemAgent: Across Qwen3-1.7B/4B and Qwen2.5-7B on benchmarks spanning 32k to 1M tokens, InfMem outperforms MemAgent by over 10 points on average after RL, while reducing latency by 3.3-5.1x. It also transfers well to LongBench QA with consistent improvements.  <br>● Robustness at extreme lengths: While baselines like YaRN collapse beyond 128k tokens and RAG struggles with dispersed evidence, InfMem remains stable up to 1M tokens, especially on complex multi-hop tasks that require synthesizing scattered bridging facts across distant document segments. | [Paper](https://arxiv.org/abs/2602.02704), [Tweet](https://x.com/omarsar0/status/2019759999170556189) |
| 6) **A-RAG** - A-RAG is an agentic RAG framework that gives LLMs direct access to hierarchical retrieval interfaces instead of relying on fixed retrieval algorithms or predefined workflows. The agent autonomously decides what to search, at which granularity, and when to stop - representing a paradigm shift from static retrieval pipelines to truly agentic information gathering. <br>● Hierarchical retrieval tools: A-RAG provides three tools operating at different granularities: keyword search for exact lexical matching at the keyword level, semantic search for dense retrieval at the sentence level, and chunk read for accessing full document chunks. The agent chooses which tool to call at each step based on the task, enabling adaptive multi-granularity retrieval.  <br>● Agentic autonomy over fixed workflows: Unlike Graph RAG (algorithm-driven, no iterative execution) and Workflow RAG (predefined steps, no autonomous strategy), A-RAG satisfies all three principles of agentic autonomy: autonomous strategy selection, iterative execution, and interleaved tool use. The model decides its own retrieval path in a ReAct-style loop.  <br>● Consistent gains across benchmarks: With GPT-5-mini as backbone, A-RAG outperforms all baselines on every benchmark tested (MuSiQue, HotpotQA, 2WikiMultiHopQA, Medical QA, Novel QA), beating strong methods like LinearRAG, HippoRAG2, and FaithfulRAG by significant margins.  <br>● Better accuracy with fewer tokens: A-RAG (Full) retrieves comparable or fewer tokens than traditional RAG methods while achieving higher accuracy. The hierarchical interface design lets the agent progressively disclose information and selectively read only the most relevant chunks, avoiding noise from irrelevant content.  <br>● Scales with test-time compute: Increasing max retrieval steps and reasoning effort both improve performance, with stronger models benefiting more from additional steps. Scaling reasoning effort from minimal to high yields approximately 25% improvement for both GPT-5-mini and GPT-5. | [Paper](https://arxiv.org/abs/2602.03442), [Tweet](https://x.com/dair_ai/status/2019061395342622947) |
| 7) **Agent Primitives** - Agent Primitives introduces reusable latent building blocks for LLM-based multi-agent systems. Inspired by how neural networks are built from composable modules like residual blocks and attention heads, the authors decompose existing MAS architectures into three recurring computation patterns that communicate via KV cache instead of natural language, reducing error accumulation and boosting efficiency. <br>● Three core primitives: Review (a Solver-Critic feedback loop for iterative self-refinement), Voting and Selection (parallel Solvers with a Selector that aggregates latent candidates), and Planning and Execution (a Planner that decomposes tasks into subgoals consumed by Executor agents). Each primitive communicates internally through KV cache concatenation rather than text generation.  <br>● KV cache over natural language: Stress tests show natural-language communication degrades sharply under long contexts and noise injection, while KV cache communication stays robust. With midpoint task injection, natural-language accuracy drops to 15.6% compliance versus 73.3% for KV cache.  <br>● Automatic composition via an Organizer: An LLM-based Organizer selects and composes primitives per query, guided by a lightweight Knowledge Pool of 45 previously successful MAS configurations. This eliminates manual system design while maintaining strong performance across tasks.  <br>● Consistent accuracy gains: Across eight benchmarks (math, code, QA) and five open-source backbones, primitives-based MAS improves accuracy by 12.0-16.5% over single-agent baselines. It also outperforms 10 existing MAS methods, including Self-Refine, AgentVerse, and MAS-GPT, on a unified Llama-3-70B evaluation.  <br>● Major efficiency improvements: Compared to text-based MAS, Agent Primitives reduces token usage and inference latency by 3-4x while achieving higher accuracy. Total overhead is only 1.3-1.6x relative to single-agent inference, making it practical for deployment. | [Paper](https://arxiv.org/abs/2602.03695), [Tweet](https://x.com/dair_ai/status/2019416738484613184) |
| 8) **Accelerating Scientific Research with Gemini** - A collection of case studies from Google Research showing how researchers used Gemini Deep Think to solve open problems, refute conjectures, and generate new proofs across theoretical computer science, information theory, cryptography, optimization, economics, and physics. The paper extracts a practical playbook of recurring techniques, including iterative refinement, cross-disciplinary knowledge transfer, counterexample search, and neuro-symbolic verification loops where the model autonomously writes and executes code to validate derivations. Notable results include identifying a fatal flaw in a cryptography preprint on SNARGs, resolving the Courtade-Kumar conjecture in information theory, and proving that the simplex is optimal for Euclidean Steiner trees. | [Paper](https://arxiv.org/abs/2602.03837), [Tweet](https://x.com/omarsar0/status/2019440943318065369) |
| 9) **Heterogeneous Computing for AI Agent Inference** - This paper introduces Operational Intensity (OI) and Capacity Footprint (CF) as two metrics that better characterize AI agent inference workloads than traditional roofline models, revealing that memory capacity - not just bandwidth or compute - is often the true bottleneck. Analysis across agent types (chatbot, coding, web-use, computer-use) shows that agentic workflows create vastly different and rapidly growing demands on hardware, with context lengths snowballing to over 1M tokens in coding agents. The authors argue for disaggregated, heterogeneous compute architectures with specialized prefill and decode accelerators, hardware-aware model co-design, and large-capacity memory disaggregation as essential directions for scaling AI agent systems. | [Paper](https://arxiv.org/abs/2601.22001), [Tweet](https://x.com/dair_ai/status/2018337881715245507) |
| 10) **OpenScholar** - OpenScholar is a fully open, retrieval-augmented language model designed for scientific literature synthesis. It retrieves passages from a datastore of 45 million open-access papers, generates citation-backed responses, and iteratively refines outputs through a self-feedback loop. On ScholarQABench, the first large-scale multi-domain benchmark for literature search, OpenScholar-8B outperforms GPT-4o by 6% and PaperQA2 by 5.5% in correctness, while achieving citation accuracy on par with human experts and being preferred over expert-written answers 51-70% of the time. | [Paper](https://www.nature.com/articles/s41586-025-10072-4), [Tweet](https://x.com/AkariAsai/status/2019113650460487726) |

## Top AI Papers of the Week (January 26 - February 1) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **Kimi K2.5: Visual Agentic Intelligence** - Kimi K2.5 is an open-source multimodal agentic model from Moonshot AI that jointly optimizes text and vision capabilities through native multimodal pretraining on 15 trillion mixed tokens, zero-vision SFT, and joint reinforcement learning. K2.5 also introduces Agent Swarm, a parallel agent orchestration framework that dynamically decomposes complex tasks into concurrent subtasks, reducing latency by up to 4.5x over single-agent baselines. <br>● Joint text-vision optimization: K2.5 uses early fusion with a lower vision ratio during pretraining (rather than late-stage heavy vision injection), achieving better results across both modalities. A key finding is that zero-vision SFT - using only text SFT data - is sufficient to activate visual reasoning and tool use, while visual RL actually improves text benchmarks like MMLU-Pro (+1.7%) and GPQA-Diamond (+2.1%).  <br>● Agent Swarm with Parallel-Agent RL: The framework trains a learnable orchestrator via RL to decompose tasks and delegate subtasks to frozen specialized subagents running in parallel. This decoupled design avoids credit assignment ambiguity and improves item-level F1 from 72.8% to 79.0% on wide-search scenarios while significantly reducing inference latency.  <br>● State-of-the-art agentic performance: K2.5 achieves 74.9% on BrowseComp (with context management), 77.1% on DeepSearchQA, and 57.4% on Seal-0, outperforming GPT-5.2, Claude Opus 4.5, and Gemini 3 Pro. It also scores 96.1% on AIME 2025, 76.8% on SWE-Bench Verified, and establishes new records in long-video comprehension.  <br>● Token-efficient RL with Toggle: K2.5 introduces Toggle, a training heuristic that alternates between budget-constrained and standard scaling phases during RL, reducing output tokens by 25-30% with negligible performance impact while maintaining strong test-time scaling capabilities. | [Paper](https://github.com/MoonshotAI/Kimi-K2.5/blob/master/tech_report.pdf), [Tweet](https://x.com/Kimi_Moonshot/status/2017249233775260021) |
| 2) **Shaping Capabilities with Token-Level Data Filtering** - Researchers from Anthropic and Stanford show that filtering pretraining data at the token level is a highly effective, scalable, and robust approach for selectively removing undesired capabilities from language models. Using medical knowledge removal as a proxy task, token-level filtering Pareto dominates document-level filtering and achieves a 7,000x compute slowdown on the target domain for 1.8B parameter models - while preserving capabilities in related fields. <br>● Token filtering beats document filtering: Inspired by data attribution research showing individual tokens vary in their influence on model capabilities, the authors filter tokens rather than whole documents. This achieves the same reduction in undesired capabilities with lower cost to benign ones, since document filtering removes many useful tokens alongside harmful ones. Sweeping across classifier thresholds on 521M models confirms that token filtering Pareto dominates document filtering.  <br>● Effectiveness scales with compute: Training models from 61M to 1.8B parameters, the authors find filtering gets more effective at larger scales. For 1.8B models, token removal causes a 7,000x effective compute slowdown on the forget domain versus just 30x for document filtering. On multiple choice medical benchmarks, filtered models score near chance, while retaining full performance on biology, STEM, and non-STEM evaluations.  <br>● 10x more robust than unlearning: Token-filtered models are 10x more robust to adversarial finetuning attacks than state-of-the-art unlearning methods. This addresses a key limitation of post-hoc approaches - once a capability exists in a base model, it is extremely hard to remove, but preventing it from forming during pretraining is far more durable.  <br>● Compatibility with alignment and SAE-based labeling: Surprisingly, models trained with token filtering generalize to refusal training better than unfiltered baselines, countering concerns that filtered models cannot be properly aligned on removed domains. The authors also introduce a novel pipeline using sparse autoencoders to label tokens and distill cheap, high-quality classifiers, showing that filtering remains effective even with noisy labels given sufficient compute. | [Paper](https://arxiv.org/abs/2601.21571), [Tweet](https://x.com/neil_rathi/status/2017286042370683336) |
| 3) **How AI Impacts Skill Formation** - Researchers from Anthropic conducted randomized experiments to study how AI assistance affects the development of software engineering skills. They find that using AI to complete coding tasks with a new Python library significantly impaired conceptual understanding, code reading, and debugging abilities - without delivering significant efficiency gains on average. <br>● Learning loss from AI assistance: In a controlled study with 52 developers learning the Python Trio library, participants using AI scored 17% lower (Cohen’s d=0.738, p=0.01) on a skills evaluation covering conceptual understanding, debugging, and code reading. The largest gap appeared in debugging questions, likely because control group participants encountered and independently resolved more errors during the task.  <br>● No significant productivity gains: Contrary to prior work showing AI-assisted coding speedups, AI did not significantly reduce task completion time in this learning context. Several participants spent up to 11 minutes composing queries to the AI assistant, offsetting potential time savings from code generation.  <br>● Six distinct AI interaction patterns: Qualitative analysis of screen recordings revealed three low-scoring patterns (AI Delegation, Progressive AI Reliance, Iterative AI Debugging) averaging below 40% quiz scores, and three high-scoring patterns (Conceptual Inquiry at 86%, Generation-Then-Comprehension at 68%, Hybrid Code-Explanation at 65%) where participants stayed cognitively engaged.  <br>● Implications for AI-assisted workflows: The findings suggest that AI-enhanced productivity is not a shortcut to competence. The high-scoring interaction patterns all involved independent thinking and cognitive effort, indicating that how AI is used matters more than whether it is used - particularly in safety-critical domains requiring human oversight of AI-generated code. | [Paper](https://arxiv.org/abs/2601.20245), [Tweet](https://x.com/AnthropicAI/status/2016960382968136138) |
| 4) **VibeTensor** - VibeTensor is an open-source deep learning system software stack from NVLabs that was fully generated by LLM-powered coding agents under high-level human guidance. The system implements a PyTorch-style eager tensor library with a C++20/CUDA core, Python and Node.js frontends, its own autograd engine, CUDA runtime, and caching allocator - demonstrating that coding agents can produce coherent system software spanning language bindings down to GPU memory management. <br>● Full-stack generated architecture: The system includes a schema-lite dispatcher, reverse-mode autograd engine, stream-ordered caching allocator with diagnostics, CUDA graph support, and a stable C ABI for dynamically loaded operator plugins. The 28B LOC codebase spans 218 core C++ files and 225 Python test files, all generated without per-change manual diff review.  <br>● AI-assisted development methodology: A two-month development cycle used a simple loop: specify scoped goals, generate code, compile and test, then broaden validation. Tests as specifications and differential checks against PyTorch served as key guardrails, with multi-agent code review catching unsafe patterns.  <br>● Kernel performance and training validation: An accompanying AI-generated kernel suite shows mixed results: 1.54x faster than FlashAttention on NanoChat-style training (batch 32, seq 2048) but 0.67x on small-batch GQA prefill. End-to-end training on H100 and Blackwell GPUs converges correctly but runs 1.7-6.2x slower than PyTorch.  <br>● The Frankenstein composition effect: The paper identifies a key failure mode where individually correct generated subsystems compose into globally suboptimal designs - for example, a correctness-first autograd gate serializes execution and starves efficient backend kernels, highlighting challenges unique to AI-generated system software. | [Paper](https://arxiv.org/abs/2601.16238), [Tweet](https://x.com/omarsar0/status/2016570992039252068) |
| 5) **Reinforcement Learning via Self-Distillation** - This paper introduces Self-Distillation Policy Optimization (SDPO), an on-policy RL algorithm that converts rich textual feedback from verifiable environments into dense credit assignment without requiring an external teacher model. SDPO uses the current model conditioned on feedback as a “self-teacher” to retrospectively identify mistakes in its own rollouts, substantially outperforming GRPO across scientific reasoning, tool use, and competitive programming. <br>● Self-teacher for dense credit assignment: Instead of learning from sparse scalar rewards like GRPO, SDPO re-evaluates the model’s original attempt after conditioning on environment feedback (runtime errors, failed tests, or successful rollouts). This produces logit-level advantages at every token position, compared to GRPO’s constant per-rollout advantages. The approach requires only minor changes to standard RLVR pipelines by swapping out the advantage computation.  <br>● Strong gains on competitive programming: On LiveCodeBench v6 with Qwen3-8B, SDPO reaches 48.8% accuracy versus 41.2% for GRPO, surpassing Claude Sonnet 4 (40.5%) and Claude Opus 4 (39.7%) on the public leaderboard. SDPO achieves GRPO’s final accuracy in 4x fewer generations, with gains growing at larger model scales - suggesting self-teaching is an emergent capability.  <br>● Effective even without rich feedback: In standard RLVR environments with only scalar rewards, SDPO treats successful rollouts as implicit feedback for failed attempts, achieving 68.8% vs. 64.1% aggregate accuracy over GRPO on scientific reasoning and tool use benchmarks. On Chemistry with OLMo3-7B, SDPO reaches GRPO’s 5-hour accuracy in just 30 minutes.  <br>● Concise reasoning without verbosity: SDPO produces responses that are 3-7x shorter than GRPO while achieving higher accuracy, avoiding circular reasoning patterns and filler phrases. At test time, SDPO accelerates discovery of solutions on difficult tasks by 3x compared to best-of-k sampling, enabling effective test-time self-distillation on individual questions. | [Paper](https://arxiv.org/abs/2601.20802), [Tweet](https://x.com/jonashuebotter/status/2016950268462608665) |
| 6) **Self-Improving Pretraining** - Self-Improving Pretraining is a new pretraining paradigm from Meta FAIR that replaces standard next-token prediction with sequence-level generation guided by an existing post-trained model acting as both a suffix rewriter and a suffix judge. The approach addresses quality, safety, and factuality issues at pretraining time rather than deferring them to post-training, yielding large gains across all three dimensions. <br>● Suffix rewriting and judging framework: The method segments pretraining data into prefix-suffix chunks. A post-trained teacher model rewrites low-quality or unsafe suffixes into superior training targets, while a separate judge scores candidate completions (original suffixes, rewrites, and policy rollouts) to provide rewards for online RL training via online DPO or reward-filtered NLL.  <br>● Strong continual pretraining gains: When applied to continual pretraining of Llama2 1.4B, the method achieves an 86.3% generation quality win rate over the baseline, a 36.2% relative improvement in factuality (42.3 to 57.6 average score), and an 18.5% relative improvement in safety (76.9 to 91.1 average score), while also improving standard evaluation benchmarks.  <br>● From-scratch pretraining improvements: Training from scratch on RedPajama yields a 31.1% absolute gain in generation quality win rate, and safety evaluations, improving from 85.2 to 97.5, demonstrating that embedding quality signals early in pretraining is highly effective.  <br>● Scaling with rollouts: Performance improves consistently with more rollouts during online DPO training (tested from 1 to 16), and the model naturally transitions from relying on suffix rewrites early in training to preferring its own high-quality rollouts as training progresses. | [Paper](https://arxiv.org/abs/2601.21343), [Tweet](https://x.com/jaseweston/status/2017071377866494226) |
| 7) **LingBot-World: Open-Source World Simulator** - LingBot-World is an open-source world simulator that evolves a video generation model into an interactive, real-time environment engine. Built on a 28B-parameter Mixture-of-Experts architecture, it achieves high-fidelity dynamics across diverse domains with sub-second latency at 16 fps, outperforming Genie 3 and Mirage 2 in dynamic degree while being fully open-source. <br>● Three-stage evolution pipeline: A progressive training strategy transforms a pretrained video model into an interactive simulator: Stage I establishes a general video prior via the Wan2.2 14B model, Stage II injects world knowledge and action control through MoE middle-training on 60-second sequences, and Stage III adapts to causal attention with few-step distillation for real-time inference.  <br>● Scalable data engine with hierarchical captioning: A hybrid data engine ingests real-world footage, game engine recordings, and Unreal Engine synthetic data. A three-layer captioning strategy (narrative, scene-static, and dense temporal) disentangles motion control from scene generation, enabling precise action-contingent dynamics learning.  <br>● Emergent spatial memory: Without explicit 3D representations, the model maintains structural integrity of landmarks after 60 seconds out of view, reasons about unobserved state evolution (vehicles continuing trajectories off-screen), and supports coherent generation up to 10 minutes. VBench evaluation shows 0.8857 dynamic degree versus 0.76 for Yume-1.5 and 0.72 for HY-World 1.5.  <br>● Versatile embodied AI applications: Beyond visual synthesis, the framework supports promptable world events (global weather/style shifts and local object injection via text), an action agent trained on Qwen3-VL-2B for autonomous exploration, and 3D reconstruction from generated videos validating geometric consistency. | [Paper](https://arxiv.org/abs/2601.20540), [Tweet](https://x.com/dair_ai/status/2016881546909929775) |
| 8) **Insight Agents: Multi-Agent System for Data Insights** - Insight Agents introduces a hierarchical multi-agent system built on a plan-and-execute paradigm for delivering personalized business insights to e-commerce sellers. The system uses a manager agent with OOD detection via a lightweight encoder-decoder model and BERT-based routing to coordinate two worker agents (data presenter and insight generator), achieving 90% accuracy with P90 latency below 15 seconds. Accepted at SIGIR 2025 and deployed for Amazon sellers in the US. | [Paper](https://arxiv.org/abs/2601.20048), [Tweet](https://x.com/omarsar0/status/2016880021030522997) |
| 9) **Communication Methods in Multi-Agent RL** - A systematic survey of 29 papers reviewing how agents coordinate in multi-agent reinforcement learning, covering fully connected message passing, implicit communication, attention-based selective methods, graph-based relational approaches, and role-based hierarchical frameworks. The analysis reveals that attention- and graph-based methods dominate recent research, while implicit communication is seeing renewed interest for its scalability in decentralized settings where explicit channels are infeasible. | [Paper](https://arxiv.org/abs/2601.12886), [Tweet](https://x.com/dair_ai/status/2016200804894728650) |
| 10) **Team of Rivals: Orchestrating Reliable AI Agents** - This paper proposes organizing AI agents into corporate-style teams with strict role boundaries and opposing incentives (planners, executors, critics, experts) to achieve reliability through careful orchestration of imperfect components. A remote code executor separates reasoning from data transformations, preventing raw tool outputs from contaminating agent context windows. The system achieves over 90% internal error interception before user exposure while maintaining acceptable latency tradeoffs. | [Paper](https://arxiv.org/abs/2601.14351), [Tweet](https://x.com/dair_ai/status/2015911896646615196) |

## Top AI Papers of the Week (January 19 - January 25) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **TTT-Discover: Learning to Discover at Test Time** - TTT-Discover introduces test-time training for scientific discovery, performing reinforcement learning at test time so the LLM can continue to train with experience specific to the test problem. Unlike prior work like AlphaEvolve that prompts a frozen LLM, this approach enables the model itself to improve while attempting to solve hard problems. <br>● Test-time reinforcement learning: The method performs RL in an environment defined by a single test problem, with a learning objective and search subroutine designed to prioritize the most promising solutions rather than maximizing average reward across attempts.  <br>● State-of-the-art across domains: TTT-Discover sets new records on Erdős’ minimum overlap problem, an autocorrelation inequality, GPUMode kernel competitions (up to 2x faster than prior art), AtCoder algorithm competitions, and single-cell denoising in biology.  <br>● Open model results: All results are achieved with OpenAI gpt-oss-120b, an open model, and can be reproduced with publicly available code, in contrast to previous best results requiring closed frontier models.  <br>● Cost-effective discovery: Test-time training runs cost only a few hundred dollars per problem using Tinker API, making scientific discovery accessible without massive compute budgets.  <br>● Learning over search: While both learning and search scale with compute, the authors argue learning has historically superseded search for hard problems (Go, protein folding), and this observation extends to test-time compute scaling for discovery. | [Paper](https://test-time-training.github.io/discover.pdf), [Tweet](https://x.com/mertyuksekgonul/status/2014394903850311797) |
| 2) **Reasoning Models Generate Societies of Thought** - This paper reveals that enhanced reasoning in models like DeepSeek-R1 and QwQ-32B emerges not from extended computation alone, but from simulating multi-agent-like interactions - a “society of thought” - enabling diversification and debate among internal cognitive perspectives with distinct personality traits and domain expertise. <br>● Multi-agent internal dynamics: Through mechanistic interpretability analysis, reasoning models exhibit much greater perspective diversity than instruction-tuned models, activating broader conflict between heterogeneous personality and expertise-related features during reasoning.  <br>● Conversational behaviors drive accuracy: The multi-agent structure manifests in question-answering, perspective shifts, and reconciliation of conflicting views. These socio-emotional roles characterizing back-and-forth conversations account for the accuracy advantage in reasoning tasks.  <br>● Emergent from accuracy rewards: Controlled reinforcement learning experiments reveal that base models naturally increase conversational behaviors when rewarded solely for reasoning accuracy, suggesting this structure emerges organically from optimization pressure.  <br>● Accelerated improvement through scaffolding: Fine-tuning models with conversational scaffolding accelerates reasoning improvement over base models, providing a practical pathway to enhance reasoning capabilities.  <br>● Parallel to collective intelligence: The findings suggest reasoning models establish a computational parallel to human collective intelligence, where diversity enables superior problem-solving when systematically structured, opening new opportunities for agent organization. | [Paper](https://arxiv.org/abs/2601.10825), [Tweet](https://x.com/omarsar0/status/2015079909048422735?s=20) |
| 3) **Memory Control for Long-Horizon Agents** - This paper introduces the Agent Cognitive Compressor (ACC), a bio-inspired mechanism that addresses degraded agent behavior in long multi-turn workflows caused by loss of constraint focus, error accumulation, and memory-induced drift. ACC replaces continuous transcript retention with a bounded internal state that updates incrementally during each interaction turn. <br>● The problem with unbounded context: Traditional approaches using transcript replay or retrieval-based memory systems create unbounded context growth and introduce vulnerabilities to corrupted information, causing agent performance to degrade over extended interactions.  <br>● Bio-inspired bounded memory: Drawing from biological memory systems, ACC maintains a bounded internal state rather than continuously growing context, enabling stable performance without the computational costs of ever-expanding transcripts.  <br>● Agent-judge evaluation framework: The authors developed an agent-judge-driven evaluation framework to assess both task success and memory-related anomalies across extended workflows in IT operations, cybersecurity response, and healthcare contexts.  <br>● Reduced cognitive drift: ACC demonstrated substantially improved stability in multi-turn interactions, showing significantly reduced hallucination and cognitive drift compared to traditional transcript replay and retrieval-based systems.  <br>● Practical foundation: The research suggests that implementing cognitive compression principles provides a practical foundation for developing reliable long-horizon AI agent systems that maintain consistent behavior over extended deployments. | [Paper](https://arxiv.org/abs/2601.11653), [Tweet](https://x.com/dair_ai/status/2014000799245107339) |
| 4) **Benchmarking Agents on Hard CLI Tasks** - Terminal-Bench 2.0 presents a carefully curated hard benchmark composed of 89 tasks in computer terminal environments inspired by problems from real workflows. Each task features a unique environment, human-written solution, and comprehensive tests for verification, addressing the gap where current benchmarks either don’t measure real-world tasks or aren’t sufficiently difficult. <br>● Challenging for frontier models: Frontier models and agents score less than 65% on the benchmark, demonstrating that Terminal-Bench meaningfully measures capabilities that current systems struggle with, unlike saturated benchmarks.  <br>● Real-world task inspiration: Tasks are derived from actual command-line workflows, ensuring the benchmark measures practical skills rather than artificial puzzles, with each task featuring unique environments reflecting diverse real scenarios.  <br>● Comprehensive verification: Every task includes human-written solutions and comprehensive tests for verification, enabling reliable and reproducible evaluation of agent performance on terminal-based tasks.  <br>● Error analysis insights: The authors conduct detailed error analysis to identify specific areas for model and agent improvement, providing actionable guidance for researchers developing more capable CLI agents.  <br>● Open evaluation infrastructure: The dataset and evaluation harness are publicly available at tbench.ai, enabling developers and researchers to benchmark their systems and contribute to advancing agent capabilities in terminal environments. | [Paper](https://arxiv.org/abs/2601.11868), [Tweet](https://x.com/Mike_A_Merrill/status/2014400516642488658) |
| 5) **Rethinking Multi-Agent Workflows** - This paper challenges the assumption that complex tasks require multiple specialized AI agents, demonstrating that a single LLM agent, through iterative dialogue, can match the performance of homogeneous multi-agent workflows while gaining efficiency from KV cache reuse. <br>● Single-agent hypothesis: The research tests whether multi-agent systems truly require multiple agents or if a single agent engaging in multi-turn conversations can replicate their performance, finding that the latter holds across diverse benchmarks.  <br>● Comprehensive evaluation: Testing across seven benchmarks spanning coding, math, QA, domain reasoning, and planning tasks demonstrates that the single-agent approach consistently matches multi-agent performance.  <br>● OneFlow algorithm: The paper introduces OneFlow, an algorithm that automatically optimizes workflows for single-agent execution, enabling practitioners to simplify complex multi-agent architectures without sacrificing capability.  <br>● Efficiency through KV cache reuse: Single-agent implementations gain substantial efficiency advantages by reusing key-value caches across conversation turns, reducing inference costs compared to multi-agent orchestration overhead.  <br>● Future directions: The work identifies that truly heterogeneous systems using different specialized LLMs remain an open research opportunity, as current multi-agent benefits may only emerge when agents have genuinely different capabilities. | [Paper](https://arxiv.org/abs/2601.12307), [Tweet](https://x.com/omarsar0/status/2014740818255282354) |
| 6) **Self-Correcting Multi-Agent LLM for Physics Simulation** - This paper introduces a self-correcting multi-agent LLM framework for language-based physics simulation and explanation. The system enables natural language queries to generate physics simulations while providing explanations of the underlying physical phenomena. <br>● Multi-agent architecture: The framework employs multiple specialized LLM agents that collaborate to translate natural language descriptions into accurate physics simulations, with each agent handling distinct aspects of the simulation pipeline.  <br>● Self-correction mechanism: Built-in self-correction capabilities allow the system to identify and fix errors in generated simulations, improving accuracy without requiring human intervention or additional training.  <br>● Language-based interface: Users can describe physics scenarios in natural language, making complex simulation tools accessible to non-experts while maintaining scientific accuracy in the outputs.  <br>● Explanation generation: Beyond simulation, the system generates natural language explanations of the physics principles at work, serving both educational and research applications.  <br>● Validation across domains: The framework demonstrates effectiveness across multiple physics domains, showing generalization capability beyond narrow task-specific applications. | [Paper](https://www.nature.com/articles/s44387-025-00057-z), [Tweet](https://x.com/omarsar0/status/2013998285040836662) |
| 7) **AI IDEs vs Autonomous Agents** - This empirical study investigates how LLM-based coding agents that autonomously generate and merge pull requests affect open-source projects compared to IDE-integrated AI assistants. Using longitudinal causal analysis with matched controls, the researchers measure development velocity and software quality outcomes. <br>● Methodology: The study employs staggered difference-in-differences with matched controls, analyzing monthly metrics spanning development velocity and quality indicators like static-analysis warnings, code complexity, and duplication rates.  <br>● Velocity gains are conditional: Substantial upfront acceleration occurs only when autonomous agents are a project’s first AI tool. Projects already using IDE assistants see minimal additional productivity benefits from adding autonomous agents.  <br>● Persistent quality concerns: Across all contexts, static-analysis warnings rise roughly 18% and cognitive complexity increases approximately 35% when autonomous agents are deployed, suggesting tensions between speed and maintainability.  <br>● Diminishing returns: Layering multiple AI assistance types produces limited additional productivity improvements, challenging the assumption that more AI tools always mean better outcomes.  <br>● First-mover effects: The research differentiates effects based on whether agents represent a project’s first exposure to AI tooling versus augmenting existing assistance, finding that the sequence of adoption matters significantly. | [Paper](https://arxiv.org/abs/2601.13597), [Tweet](https://x.com/dair_ai/status/2014365703718183191) |
| 8) **Efficient Agents** - A comprehensive review examining how to make LLM-based agents more efficient for real-world deployment, focusing on three core components: memory (bounding context via compression), tool learning (RL strategies to minimize tool invocation), and planning (controlled search mechanisms). The paper characterizes efficiency through dual metrics and Pareto frontier analysis between effectiveness and cost. | [Paper](https://arxiv.org/abs/2601.14192), [Tweet](https://x.com/dair_ai/status/2014743904072175946) |
| 9) **Task-Decoupled Planning for Long-Horizon Agents** - Task-Decoupled Planning (TDP) is a training-free framework that restructures agent planning by decomposing tasks into a directed acyclic graph of sub-goals using three components: Supervisor, Planner, and Executor. By isolating reasoning to individual subtasks through scoped contexts, TDP prevents error cascading and reduces token consumption by up to 82% while outperforming baselines on TravelPlanner, ScienceWorld, and HotpotQA. | [Paper](https://arxiv.org/abs/2601.07577), [Tweet](https://x.com/omarsar0/status/2012877899360297408) |
| 10) **Large-Scale Study on Multi-Agent AI Systems Development** - An empirical analysis of over 42,000 commits and 4,700 resolved issues across eight leading multi-agent frameworks (LangChain, CrewAI, AutoGen). Key findings: feature enhancements dominate at 40.8% of changes versus 27.4% bug fixes, bugs represent 22% of issues, with agent coordination challenges at 10%, and issue reporting surged notably beginning in 2023. | [Paper](https://arxiv.org/abs/2601.07136), [Tweet](https://x.com/omarsar0/status/2013262699678068758) |

## Top AI Papers of the Week (January 12 - January 18) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **Learning Latent Action World Models In The Wild** - Meta AI researchers address learning world models from in-the-wild videos without requiring explicit action labels, expanding beyond simple robotics simulations and video games to real-world video data with diverse embodiments and uncontrolled conditions. <br>● Latent action learning: The work demonstrates that continuous but constrained latent actions can capture the complexity of actions from in-the-wild videos, outperforming vector quantization approaches commonly used in prior work.  <br>● Cross-video transfer: Changes in the environment coming from agents, such as humans entering a room, can be transferred across different videos, indicating that the learned latent actions capture meaningful and generalizable environmental interactions.  <br>● Universal interface: Despite challenges from diverse embodiments across videos, the researchers train a controller that maps known actions to latent ones, enabling latent actions to serve as a universal interface for downstream planning tasks.  <br>● Comparable to action-conditioned baselines: The latent action approach achieves comparable performance to action-conditioned baselines on planning tasks, demonstrating practical viability without requiring explicit action labels during training.  <br>● Scaling to real-world data: The work represents progress toward scaling latent action models to realistic video data, addressing fundamental challenges in learning from diverse, uncontrolled video sources that lack action annotations. | [Paper](https://arxiv.org/abs/2601.05230), [Tweet](https://x.com/omarsar0/status/2011076284164542639) |
| 2) **Extending Context by Dropping Positional Embeddings** - DroPE introduces a method for extending a language model’s context window after pretraining without expensive long-context fine-tuning. The approach involves removing positional embeddings from a pretrained model and performing brief recalibration at the original context length. <br>● Core insight: Positional embeddings serve as a “training-time scaffold” - beneficial during pretraining but detrimental for extrapolation. RoPE enables faster attention non-uniformity development during training, but becomes problematic at test time when sequences exceed training length.  <br>● The length generalization problem: Popular RoPE scaling methods preserve perplexity but essentially “crop” effective context, failing at retrieval tasks requiring long-range attention. DroPE addresses this by completely removing the positional scaffold after training.  <br>● Simple methodology: The approach is straightforward: train or obtain a pretrained RoPE-based model, remove positional embeddings post-pretraining, then recalibrate briefly using as little as 0.5-2% of the original pretraining budget.  <br>● Strong recovery: Models regain 95%+ in-context performance after less than 5B recalibration tokens. On needle-in-haystack tasks, DroPE substantially outperforms RoPE-scaling methods that fail at long-range retrieval.  <br>● Scalability and benchmarks: Validated on models up to 7B parameters trained on trillions of tokens. Improves base SmolLM scores by 10x on LongBench and enables zero-shot context extension to 2x training length without task-specific fine-tuning. | [Paper](https://pub.sakana.ai/DroPE/), [Tweet](https://x.com/SakanaAILabs/status/2010508366574186825) |
| 3) **Self-Evolving Search Agents Without Training Data** - Dr. Zero introduces a framework for developing multi-turn search agents that improve themselves autonomously without labeled training data. A proposer generates diverse questions to train a solver initialized from the same base model, creating a self-evolution loop with automated curriculum difficulty scaling. <br>● Self-evolution loop: The framework establishes a feedback mechanism where a problem proposer creates questions and a solver learns from them. As the solver improves, difficulty automatically increases, creating an automated curriculum without human intervention.  <br>● Hop-Grouped Relative Policy Optimization (HRPO): A novel training method that clusters structurally similar questions to construct group-level baselines. This approach reduces computational overhead while maintaining performance quality compared to instance-level optimization.  <br>● Data-free performance: Experimental results demonstrate that the approach matches or surpasses fully supervised search agents, proving sophisticated multi-turn reasoning capabilities can emerge through self-evolution alone.  <br>● Reduced data dependency: The work shows that complex reasoning and search functionalities can develop without external training data, potentially reducing dependency on expensive labeled datasets in AI development.  <br>● Scalable self-improvement: The proposer-solver architecture enables continuous improvement cycles where the model effectively teaches itself increasingly difficult problems, suggesting a path toward more autonomous agent development. | [Paper](https://arxiv.org/abs/2601.07055), [Tweet](https://x.com/dair_ai/status/2011458048443994185) |
| 4) **Unified Long-Term and Short-Term Memory for LLM Agents** - AgeMem introduces a unified framework that integrates both long-term and short-term memory operations into an LLM agent’s decision-making policy. The system enables agents to autonomously determine what and when to store, retrieve, update, summarize, or discard information by exposing memory operations as tool-based actions. <br>● Unified memory management: Unlike existing solutions that treat long-term and short-term memory separately with inflexible heuristics, AgeMem combines both into a single learnable policy that adapts to task requirements dynamically.  <br>● Memory as tool actions: The framework exposes memory operations (store, retrieve, update, summarize, discard) as callable tools, allowing the agent to learn optimal memory strategies through interaction rather than relying on predefined rules.  <br>● Progressive reinforcement learning: A three-stage training approach with a specialized “step-wise GRPO” algorithm handles the sparse and discontinuous rewards created by memory operations, enabling stable learning of complex memory policies.  <br>● Strong benchmark performance: Testing across five long-horizon benchmarks demonstrates that AgeMem outperforms comparable systems by improving task performance, memory quality, and context efficiency simultaneously.  <br>● Architecture agnostic: The approach works with multiple LLM architectures, suggesting the learned memory management strategies transfer across different base models and task domains. | [Paper](https://arxiv.org/abs/2601.01885), [Tweet](https://x.com/omarsar0/status/2010712137933730234) |
| 5) **Active Context Compression for LLM Agents** - Focus introduces an agent-centered architecture that enables LLM agents to autonomously manage their own memory by deciding when to consolidate learnings into a persistent “Knowledge” block and actively prune raw interaction history. The design is inspired by the biological navigation patterns of Physarum polycephalum (slime mold). <br>● The context bloat problem: LLM agents struggle with extended tasks as interaction history accumulates, causing computational expenses to increase, processing delays to worsen, and reasoning to deteriorate from distraction by irrelevant prior mistakes.  <br>● Autonomous memory management: Unlike passive external summarization, Focus agents autonomously choose when to store important discoveries and remove raw interaction records. The system performed 6.0 autonomous consolidations per assignment on average.  <br>● Significant token reduction: Tested on context-heavy SWE-bench Lite cases using Claude Haiku 4.5, Focus reduces token consumption by 22.7% (14.9M to 11.5M tokens) while preserving identical accuracy (60% for both agents), with reductions reaching 57% on particular instances.  <br>● Bio-inspired optimization: The architecture models biological navigation patterns where organisms efficiently manage resources and pathways, applying similar principles to context management in AI agents.  <br>● Production-ready toolkit: The system uses a refined toolkit matching production standards, including a persistent bash and string-replacement editor, demonstrating practical applicability for real-world software engineering tasks. | [Paper](https://arxiv.org/abs/2601.07190), [Tweet](https://x.com/dair_ai/status/2011806092737827206) |
| 6) **Agent-as-a-Judge** - This comprehensive survey traces the evolution from LLM-based evaluation to agentic evaluation approaches, establishing the first taxonomy for this paradigm shift. As evaluation tasks grow more intricate and specialized, traditional single-pass language model judges become insufficient. <br>● Beyond LLM-as-a-Judge: The paper identifies critical limitations of traditional LLM judges and how agentic approaches overcome them through planning, tool-augmented verification, multi-agent collaboration, and persistent memory.  <br>● Developmental taxonomy: The survey creates a structured taxonomy organizing core methodologies that characterize the shift from static evaluation to dynamic, agent-based assessment systems.  <br>● Enhanced capabilities: Agentic judges enable evaluations that are more robust, verifiable, and nuanced compared to single-pass reasoning approaches, particularly for complex tasks requiring multi-step verification.  <br>● Domain applications: The work examines applications across both general and professional domains, showing how agentic evaluation adapts to specialized requirements in different fields.  <br>● Research roadmap: Beyond surveying current methods, the paper analyzes frontier challenges and proposes research directions, offering practitioners a clear roadmap for developing next-generation evaluation systems. | [Paper](https://arxiv.org/abs/2601.05111), [Tweet](https://x.com/dair_ai/status/2010500988592095358) |
| 7) **Efficient Lifelong Memory for LLM Agents** - SimpleMem introduces a memory framework built on semantic lossless compression that addresses the tension between maintaining comprehensive long-term memory and minimizing token overhead for LLM agents. The approach achieves a 26.4% F1 improvement over baselines while reducing token consumption by up to 30-fold during inference. <br>● Semantic structured compression: The first stage applies filtering to transform unstructured interactions into compact, multi-view indexed memory units, preserving essential information while dramatically reducing storage requirements.  <br>● Recursive memory consolidation: An asynchronous process reduces redundancy by integrating related memory units into higher-level representations, similar to how human memory consolidates experiences during rest periods.  <br>● Adaptive query-aware retrieval: The system dynamically adjusts the retrieval scope based on query complexity, constructing context efficiently by pulling only the most relevant memories rather than fixed-size chunks.  <br>● Strong efficiency gains: Experimental results demonstrate token consumption reduced by up to 30-fold during inference while improving accuracy, making long-horizon agent tasks practically feasible without prohibitive computational costs.  <br>● Balanced performance: The framework provides a practical solution for deploying agents that need comprehensive memory without sacrificing response quality, addressing a critical bottleneck in real-world agent applications. | [Paper](https://arxiv.org/abs/2601.02553), [Tweet](https://x.com/dair_ai/status/2010720188686348593) |
| 8) **Ministral 3** - Mistral AI releases Ministral 3, a family of compact language models (3B, 8B, 14B parameters) designed for compute and memory-constrained applications from mobile to edge deployments. Created through Cascade Distillation (iterative pruning with continued training), each size offers pretrained, instruction-finetuned, and reasoning variants with integrated image understanding, released under Apache 2.0. | [Paper](https://arxiv.org/abs/2601.08584), [Tweet](https://x.com/qtnx_/status/2011510403550024087) |
| 9) **UniversalRAG** - UniversalRAG introduces a RAG system that handles knowledge retrieval from heterogeneous sources containing multiple data types (text, images, videos) with varying granularities. Rather than forcing diverse modalities into a single embedding space where embeddings cluster by modality rather than meaning, it uses modality-aware routing to dynamically select appropriate corpus and granularity for each query, outperforming both unimodal and unified multimodal RAG baselines across 10 benchmarks. | [Paper](https://universalrag.github.io/), [Tweet](https://x.com/omarsar0/status/2011442693134754243) |
| 10) **MemRL** - MemRL enables LLM agents to improve continuously without retraining by separating a frozen model’s reasoning from an evolving memory system. A Two-Phase Retrieval mechanism filters candidates by semantic relevance, then ranks them using learned Q-values that improve through trial-and-error, outperforming existing methods on HLE, BigCodeBench, ALFWorld, and Lifelong Agent Bench. | [Paper](https://arxiv.org/abs/2601.03192), [Tweet](https://x.com/dair_ai/status/2011086096986443905) |

## Top AI Papers of the Week (January 5 - January 11) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **On the Slow Death of Scaling** - This essay by Sara Hooker challenges the decade-long assumption that scaling compute always leads to better AI performance. It argues that the relationship between training compute and performance is highly uncertain and rapidly changing, with smaller models now routinely outperforming much larger ones. <br>● Diminishing returns of scale: Smaller models like Llama-3 8B and Aya 23 8B now outperform far larger models like Falcon 180B and BLOOM 176B despite having only a fraction of the parameters. This trend is systematic, not isolated.  <br>● Algorithmic improvements matter more: Progress has been driven by instruction finetuning, model distillation, chain-of-thought reasoning, preference training, and retrieval augmented generation - techniques that add little training compute but yield significant performance gains.  <br>● Scaling laws have limits: Scaling laws only reliably predict pre-training test loss, not downstream task performance. Many capabilities display irregular scaling curves, and small sample sizes make predictions statistically weak.  <br>● New optimization spaces: Future progress will come from inference-time compute, malleable synthetic data that can be optimized on-the-fly, and better human-AI interfaces rather than simply adding more parameters.  <br>● Cultural implications: The belief in scaling has marginalized academia, concentrated breakthroughs in wealthy regions, and led industry labs to stop publishing, reshaping the entire culture of AI research. | [Paper](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=5877662), [Tweet](https://x.com/sarahookr/status/2008527272798826689) |
| 2) **Recursive Language Models** - Recursive Language Models (RLMs) are a general inference strategy that allows LLMs to process arbitrarily long prompts by treating them as part of an external environment. Rather than feeding long contexts directly into the model, RLMs load the prompt as a variable in a Python REPL and let the LLM programmatically examine, decompose, and recursively call itself over snippets. <br>● Scaling beyond context windows: RLMs successfully handle inputs up to two orders of magnitude beyond model context windows, scaling to the 10M+ token regime while maintaining strong performance.  <br>● Outperforming base models: On information-dense tasks like OOLONG-Pairs, GPT-5 achieves less than 0.1% F1 while RLM(GPT-5) reaches 58% F1. RLMs outperform base models and common long-context scaffolds by up to 2x on diverse benchmarks.  <br>● Emergent decomposition patterns: Without explicit training, RLMs exhibit sophisticated behaviors including filtering context using regex queries based on model priors, chunking and recursive sub-calling, and answer verification through small-context sub-LM calls.  <br>● Cost-effective inference: RLMs maintain comparable or lower costs than base model calls at median, with the ability to selectively view context rather than ingesting entire inputs like summarization approaches.  <br>● Task complexity scaling: While base LLM performance degrades rapidly with both input length and task complexity, RLMs degrade at a much slower rate, maintaining effectiveness even on quadratically-scaling tasks. | [Paper](https://arxiv.org/abs/2512.24601), [Tweet](https://x.com/omarsar0/status/2009988633705742653) |
| 3) **Adversarial Program Evolution with LLMs** - Digital Red Queen (DRQ) introduces an algorithm where LLMs evolve assembly-like programs called “warriors” that compete for control of a virtual machine in the game of Core War. Rather than optimizing toward static objectives, DRQ embraces “Red Queen” dynamics where goals continually shift based on competition, demonstrating how adversarial self-play can drive the evolution of increasingly sophisticated programs. <br>● Core War as testbed: The classic programming game serves as an ideal environment for studying adversarial adaptation, where programs must simultaneously attack opponents and defend themselves in shared memory space.  <br>● Emergent generalization: Evolved warriors become increasingly effective against unseen opponents, suggesting that competitive dynamics produce more robust solutions than static optimization objectives.  <br>● Behavioral convergence: Despite independent evolutionary runs, warriors show paradoxical behavioral convergence, indicating that competitive pressure discovers similar successful strategies across different lineages.  <br>● Dynamic objectives outperform static: The research demonstrates that continually shifting competitive objectives can outperform traditional static optimization for evolving general-purpose solutions.  <br>● Broad applications: The approach has implications for cybersecurity (evolving attack/defense strategies), evolutionary biology (modeling arms races), and AI safety (understanding adversarial dynamics in multi-agent systems). | [Paper](https://arxiv.org/abs/2601.03335), [Tweet](https://x.com/SakanaAILabs/status/2009295976746635364) |
| 4) **Nemotron-Cascade** - Nemotron-Cascade introduces cascaded domain-wise reinforcement learning (Cascade RL) to build general-purpose reasoning models capable of operating in both instruct and deep thinking modes. Rather than blending heterogeneous prompts from different domains, Cascade RL orchestrates sequential, domain-wise RL stages that reduce engineering complexity while delivering state-of-the-art performance. <br>● Sequential domain-wise RL: The approach chains RLHF, instruction-following RL, math RL, code RL, and SWE RL in sequence. Subsequent stages rarely degrade earlier domain performance and may even improve it, avoiding catastrophic forgetting.  <br>● RLHF as reasoning booster: RLHF for alignment, when used as a pre-step, boosts reasoning ability far beyond mere preference optimization, serving as a foundation for subsequent domain-specific RL stages.  <br>● Strong competitive coding results: The 14B model outperforms its SFT teacher DeepSeek-R1-0528 on LiveCodeBench v5/v6/Pro and achieves silver-medal performance at the 2025 International Olympiad in Informatics (IOI).  <br>● Cross-domain excellence: The 8B model achieves 71.1% on LiveCodeBench V6, 37.2% on SWE-bench Verified, and 80.1% on AIME 2025, outperforming larger models like Qwen3-8B and matching or exceeding frontier reasoning models.  <br>● Transparent recipes: NVIDIA shares complete training and data recipes, including multi-stage SFT, reward modeling, and domain-specific RL configurations for reproducibility. | [Paper](https://arxiv.org/abs/2512.13607), [Tweet](https://x.com/omarsar0/status/2008240593257066816) |
| 5) **GDPO** - GDPO addresses a critical flaw in training language models with multiple competing objectives. The authors discover that when applying Group Relative Policy Optimization (GRPO) to multi-reward settings, normalizing distinct rollout reward combinations causes them to collapse into identical advantage values, degrading training signal quality and stability. <br>● Fundamental flaw identified: Standard GRPO normalizes rewards across all objectives together, which causes distinct reward combinations to collapse into nearly identical advantage values—destroying the nuanced signal needed for multi-objective optimization.  <br>● Decoupled normalization: GDPO decouples the normalization of individual rewards, more faithfully preserving their relative differences and enabling more accurate multi-reward optimization across competing objectives.  <br>● Consistent improvements: GDPO demonstrated gains over GRPO across three domains: tool calling, mathematical reasoning, and code generation, improving both correctness metrics (accuracy, defect rates) and constraint adherence (format compliance, output length).  <br>● Practical multi-objective training: The approach enables training models that must simultaneously optimize for multiple goals, such as being accurate while following format constraints, without the objectives interfering destructively.  <br>● Drop-in replacement: GDPO can serve as a drop-in replacement for GRPO in multi-reward RL pipelines, requiring minimal changes to existing training infrastructure while providing more stable and effective optimization. | [Paper](https://arxiv.org/abs/2601.05242), [Tweet](https://x.com/shizhediao/status/2009481573217784016) |
| 6) **Training AI Co-Scientists Using Rubric Rewards** - This paper from Meta Superintelligence Labs presents a scalable method to train language models to generate better research plans without expensive human supervision or real-world execution. The approach automatically extracts research goals and goal-specific grading rubrics from scientific papers, then uses reinforcement learning with self-grading to improve plan generation. <br>● Automated data extraction: Research goals and grading rubrics are automatically extracted from papers across ML, medical, and arXiv domains. Human experts validated that 84% of rubric items capture necessary requirements for good research plans.  <br>● Self-grading with privileged information: A frozen copy of the initial model acts as a grader, using extracted rubrics as privileged information to evaluate plans. This creates a generator-verifier gap that enables training without external supervision.  <br>● Strong human validation: In a 225-hour study with ML experts, the finetuned Qwen3-30B model’s plans were preferred over the initial model for 70% of research goals, with experts rating them as sounder and more likely to lead to better outcomes.  <br>● Cross-domain generalization: Models trained on one domain generalize significantly to others. The medical-finetuned model achieved 15% relative improvement on ML tasks and 17.5% on arXiv tasks, suggesting the approach learns generally desirable research plan qualities.  <br>● Competitive with frontier models: The finetuned 30B model becomes competitive with Grok-4-Thinking, achieving 12-22% relative improvements across domains, though GPT-5-Thinking remains the top performer. | [Paper](https://arxiv.org/abs/2512.23707), [Tweet](https://x.com/ShashwatGoel7/status/2006005049982681135) |
| 7) **Confucius Code Agent** - Confucius Code Agent (CCA) is a software engineering agent designed to operate on large-scale codebases. Built on the Confucius SDK, it introduces a three-axis design philosophy separating Agent Experience (AX), User Experience (UX), and Developer Experience (DX) to enable robust multi-step reasoning and modular tool use. <br>● Hierarchical working memory: Uses adaptive context compression to maintain essential state during long-horizon reasoning without exceeding context limits. A planner agent summarizes earlier turns into structured plans, reducing prompt length by over 40% while preserving key reasoning chains.  <br>● Persistent note-taking: A dedicated note-taking agent distills interaction trajectories into structured Markdown notes, capturing both successful strategies and failure cases for cross-session learning. This reduces token costs by approximately 11k and improves resolve rates on repeated tasks.  <br>● Modular extension system: Tool-use behaviors are factored into typed extensions that attach to the orchestrator, enabling reusable, auditable, and adaptable capabilities across different agents and tool stacks.  <br>● Meta-agent automation: A meta-agent automates a build-test-improve loop that synthesizes, evaluates, and refines agent configurations, enabling rapid adaptation to new environments and tasks without manual prompt engineering.  <br>● Strong benchmark results: On SWE-Bench-Pro, CCA achieves 54.3% Resolve@1 with Claude 4.5 Opus, exceeding prior research baselines. With Claude 4.5 Sonnet, CCA reaches 52.7%, outperforming Claude 4.5 Opus with Anthropic’s proprietary scaffold at 52.0%, demonstrating that scaffolding can outweigh raw model capability. | [Paper](https://arxiv.org/abs/2512.10398), [Tweet](https://x.com/ZhentingQi/status/2008611973622047147) |
| 8) **SciSciGPT** - SciSciGPT is an open-source AI collaborator that uses the science of science domain as a testbed for LLM-powered research tools. Its multi-agent architecture with five specialized modules automates complex research workflows and completes tasks in about 10% of the time required by experienced researchers while producing higher-quality outputs. | [Paper](https://www.nature.com/articles/s43588-025-00906-6), [Tweet](https://x.com/dashunwang/status/2008646021874946230) |
| 9) **SWE-EVO** - SWE-EVO introduces a benchmark for evaluating coding agents on long-horizon software evolution tasks that require multi-step modifications spanning an average of 21 files per task. The benchmark reveals significant limitations of current agents: GPT-5 with OpenHands achieves only 21% on SWE-EVO compared to 65% on SWE-Bench Verified, highlighting the gap between isolated bug fixes and realistic software development scenarios. | [Paper](https://arxiv.org/abs/2512.18470), [Tweet](https://x.com/omarsar0/status/2007825862721232956) |
| 10) **Deep Delta Learning** - Deep Delta Learning introduces a novel “Delta Operator” that generalizes residual connections by modulating the identity shortcut with a learnable, data-dependent geometric transformation. This enables networks to dynamically interpolate between identity mapping, orthogonal projection, and geometric reflection, allowing selective forgetting of features rather than just accumulation. | [Paper](https://arxiv.org/abs/2601.00417), [Tweet](https://x.com/omarsar0/status/2008209648298684857) |

## Top AI Papers of the Week (December 29 - January 4) - 2026
| **Paper**  | **Links** |
| ------------- | ------------- |
| 1) **End-to-End Test-Time Training for Long Context** - This paper reframes long-context language modeling as a continual learning problem rather than architecture design. TTT-E2E uses a standard Transformer with sliding-window attention that continues learning at test time via next-token prediction, compressing context into its weights rather than storing all key-value pairs. <br>● Test-time training approach: The model learns at test time by predicting next tokens on the given context, compressing information into weights. This is combined with meta-learning at training time to prepare the model’s initialization for test-time learning.  <br>● End-to-end in two ways: The inner loop directly optimizes next-token prediction loss, while the outer loop optimizes the final loss after TTT via gradients of gradients. This contrasts with prior TTT methods and dynamic evaluation approaches.  <br>● Scaling with context length: For 3B models trained on 164B tokens, TTT-E2E scales with context length the same way as full attention Transformers, while alternatives like Mamba 2 and Gated DeltaNet do not maintain performance in longer contexts.  <br>● Efficient inference: Similar to RNNs, TTT-E2E has constant inference latency regardless of context length, making it 2.7x faster than full attention for 128K context on H100 while achieving comparable or better loss. | [Paper](https://test-time-training.github.io/e2e.pdf), [Tweet](https://x.com/karansdalal/status/2005704608996540887) |
| 2) **Geometric Memory in Sequence Models** - This paper identifies a dramatically different form of how deep sequence models store factual information called geometric memory, contrasting with the traditional associative memory view. Models synthesize embeddings encoding global relationships between all entities, even ones that never co-occur in training. <br>● Two memory paradigms: Associative memory uses brute-force lookup of co-occurring entities with arbitrary embeddings. Geometric memory instead encodes global structure in carefully arranged embeddings where dot products capture multi-hop distances between entities.  <br>● Powerful reasoning transformation: Geometric memory transforms hard reasoning tasks involving multi-step composition into easy-to-learn 1-step navigation tasks. Models succeed at path-finding on massive graphs when memorizing edges in weights, despite being designed to fail.  <br>● Unexplained emergence: The geometry is learned even when it is more complex than brute-force lookup, without global supervision, rank constraints, or obvious architectural pressures. This creates a fundamental memorization puzzle.  <br>● Spectral bias explanation: By analyzing connections to Node2Vec, the researchers demonstrate that geometry stems from spectral bias arising naturally from cross-entropy loss minimization. Node2Vec models show more strongly geometric embeddings than Transformers, pointing to headroom for improvement. | [Paper](https://arxiv.org/abs/2510.26745), [Tweet](https://x.com/dair_ai/status/2005480659209400789) |
| 3) **Universal Reasoning Model** - This paper investigates why universal transformers excel at complex reasoning tasks like ARC-AGI. The key finding: performance gains come primarily from recurrent inductive bias and strong nonlinear components rather than elaborate architectural designs. <br>● Recurrent mechanism matters most: Through extensive ablation studies, the researchers show that reasoning capability beyond standard transformers comes from the recurrent mechanism of universal transformers, not from overly elaborate designs in prior work.  <br>● ConvSwiGLU enhancement: The Universal Reasoning Model (URM) augments the standard SwiGLU feed-forward block with depthwise short convolution, injecting local contextual interactions into the gating mechanism without increasing sequence-level complexity.  <br>● Truncated backpropagation: The approach uses truncated backpropagation through loops, enabling efficient training of the recurrent architecture while maintaining strong performance on reasoning tasks.  <br>● State-of-the-art ARC-AGI results: URM achieves 53.8% pass@1 on ARC-AGI 1 and 16.0% pass@1 on ARC-AGI 2, substantially outperforming prior UT-based models like TRM (40%) and HRM (32%) on ARC-AGI 1. | [Paper](https://arxiv.org/abs/2512.14693), [Tweet](https://x.com/omarsar0/status/2005640015964250267) |
| 4) **AI Agents for Coding in 2025** - This study from UC San Diego and Cornell examines how experienced software developers (3+ years) actually use AI coding agents, through field observations (N=13) and surveys (N=99). The key finding: professional developers don’t “vibe code” - they carefully control agents through planning and supervision. <br>● Control over vibing: Unlike the “vibe coding” trend, where developers trust AI without reviewing code, experienced professionals maintain careful oversight. They plan before implementing and validate all agentic outputs to ensure software quality.  <br>● Productivity with quality: Developers value agents as a productivity boost while still prioritizing software quality attributes. Some reported feeling their productivity increased tenfold, though they emphasized maintaining control over the process.  <br>● Task suitability: Agents perform well on well-described, straightforward tasks but struggle with complex tasks. The study found agents suitable for code generation, debugging, and boilerplate, but less effective for architectural decisions.  <br>● Positive sentiment with control: Developers generally enjoy using agents as long as they remain in control. A notable randomized trial found experienced maintainers were actually slowed by 19% when using AI, highlighting the importance of proper integration strategies. | [Paper](https://arxiv.org/abs/2512.14012), [Tweet](https://x.com/omarsar0/status/2006063755449504154) |
| 5) **Manifold-Constrained Hyper-Connections** - This DeepSeek paper proposes Manifold-Constrained Hyper-Connections (mHC), a framework that extends residual connections by expanding residual stream width while restoring training stability. The key insight: unconstrained Hyper-Connections compromise identity mapping, causing training instability at scale. <br>● Identity mapping restoration: mHC projects residual connection matrices onto the Birkhoff polytope using the Sinkhorn-Knopp algorithm, constraining them to doubly stochastic matrices. This preserves the feature mean during propagation and prevents vanishing or exploding signals.  <br>● Stability at scale: Standard Hyper-Connections showed loss surges around 12k steps with gradient norm instability and Amax Gain Magnitude peaks of 3000. mHC maintains stable training by ensuring the composite mapping across layers preserves conservation properties.  <br>● Efficient infrastructure: The approach uses kernel fusion with TileLang, selective recomputing to reduce memory footprint, and overlapped communication within the DualPipe schedule. This introduces only 6.7% additional time overhead at expansion rate n=4.  <br>● Scalable performance: Experiments demonstrate mHC maintains the performance advantages of Hyper-Connections while enabling training at scale, offering a practical path for scaling via residual stream width rather than just model FLOPs or data size. | [Paper](https://arxiv.org/abs/2512.24880), [Tweet](https://x.com/jiqizhixin/status/2006637266190610450?s=20) |
| 6) **Spacing Effect for Generalization** - Researchers from Tsinghua University investigate how the spacing effect - a well-documented learning principle where spaced intervals between training improve retention - can enhance generalization in both biological and artificial neural networks. <br>● Bio-inspired hypothesis: The spacing effect promotes integration of input and innate variations during learning, enabling better generalization to novel but related scenarios. The researchers test this by introducing bio-inspired spacing mechanisms into artificial neural networks.  <br>● Spaced dropout implementation: The approach implements structured dropout where probability varies periodically to introduce structured neuronal variability during training. Test accuracy follows a U-shaped trend, indicating optimal performance at intermediate variation strengths.  <br>● Cross-architecture validation: Performance gains from spaced dropout are demonstrated across different network architectures and benchmark datasets, showing the approach generalizes beyond specific model types.  <br>● Flatter loss landscapes: Theoretical and empirical analyses show that spacing effect benefits stem from convergence to flatter loss landscapes during stochastic gradient descent, resulting in better real-world performance and stronger resistance to noisy data. | [Paper](https://www.biorxiv.org/content/10.64898/2025.12.18.695340v1), [Tweet](https://x.com/dair_ai/status/2006080371147055497) |
| 7) **SAGA** - SAGA (Scientific Autonomous Goal-evolving Agent) introduces a framework for automating objective function design in AI-driven scientific discovery. Rather than optimizing fixed objectives specified by scientists, SAGA dynamically reformulates research goals throughout the discovery process to avoid reward hacking issues. <br>● Bi-level architecture: SAGA employs an outer loop where LLM agents analyze optimization outcomes and propose refined objectives, while an inner loop performs solution optimization. This enables systematic exploration of objective trade-offs that remain invisible in traditional fixed-objective approaches.  <br>● Three automation modes: The framework offers co-pilot (human collaboration on analysis and planning), semi-pilot (human feedback to analyzer only), and autopilot (fully automated) modes for flexible human-AI interaction.  <br>● Diverse scientific applications: SAGA was validated across antibiotic design for K. pneumoniae, inorganic materials design (permanent magnets, superhard materials), functional DNA sequence design, and chemical process flowsheets.  <br>● Strong performance: In antibiotic design, SAGA achieved drug-like molecules with high predicted activity while baselines either failed to optimize activity or produced chemically invalid structures. For materials, SAGA found 15 novel stable structures within 200 DFT calculations, outperforming MatterGen. In DNA design, SAGA improved MPRA specificity by at least 48% over baselines. | [Paper](https://arxiv.org/abs/2512.21782), [Tweet](https://x.com/dair_ai/status/2006742260734636461) |
| 8) **Step-DeepResearch** - Step-DeepResearch is a 32B parameter deep research agent that rivals OpenAI and Gemini DeepResearch through atomic capability training - decomposing research into planning, information gathering, cross-source verification, and report writing. Achieving 61.42 on Scale AI ResearchRubrics with a streamlined ReAct-style design, it outperforms larger models while being the most cost-effective deep research agent available. | [Paper](https://arxiv.org/abs/2512.20491), [Tweet](https://x.com/omarsar0/status/2005378485842477298) |
| 9) **MACI** - This paper argues that LLMs are not fundamentally limited as pattern matchers - the real bottleneck is the lack of a System-2 coordination layer. The authors propose MACI, an architecture implementing three mechanisms: baiting (behavior-modulated debate), filtering (Socratic judging), and persistence (transactional memory) to enable goal-directed reasoning on top of LLM substrates. | [Paper](https://arxiv.org/abs/2512.05765), [Tweet](https://x.com/omarsar0/status/2006750025263800655) |
| 10) **AgentReuse** - AgentReuse addresses latency bottlenecks in LLM-driven agents by caching and reusing plans for similar requests, observing that about 30% of agent requests are identical or similar. Using intent classification for semantic similarity rather than surface-level text comparison, the system achieves a 93% effective plan reuse rate and 93.12% latency reduction compared to systems without plan reuse. | [Paper](https://arxiv.org/abs/2512.21309), [Tweet](https://x.com/omarsar0/status/2005799762252136537) |
