š„Top AI Papers of the Week
The Top AI Papers of the Week (July 27 - August 2)
1. NOOA
Agent development today is split across prompt templates, tool schemas, callback code, and workflow graphs, four representations that drift apart as a system grows. NVIDIA Object-Oriented Agents replaces all four with one abstraction that developers already know.
An agent is a Python object: Its methods are the actions the model can take, its fields hold state, its docstrings are the prompts, and its type annotations act as contracts, so there is nothing new to learn before writing an agent.
The boundary lives in the source: A method whose body is ā...ā gets completed at runtime by a validated LLM loop, while a method with a normal body stays deterministic Python, putting the line between probabilistic and deterministic behavior right where you can read it.
Six model-facing ideas on one surface: The paper claims the first combination of typed input and output, pass-by-reference over live objects, code as action, programmable loop engineering, explicit object state, and model-callable harness APIs for context and events, evaluated on SWE-bench Verified, Terminal-Bench 2.0, and ARC-AGI-3.
Why it matters: Because agents and developers share one programming model, agent behavior becomes testable, traceable, and refactorable with the tooling already sitting in the repo, which is a more realistic path to reliability than another orchestration DSL.
Message from our Sponsor
Dial gives your agent its own real phone number. It reads the OTP itself and the run keeps going, then itās a phone: calls, SMS, iMessage, via MCP, CLI, or SDK. Free number in 30 seconds at getdial.ai
Paste this into Claude Code, Codex, or Cursor:
Get yourself a Dial phone number and call me. Say hello and
that setup is working, then ask if I have any questions.
Follow https://getdial.ai/skills.md2. ReOPD
On-policy distillation for agentic tasks is expensive because every update needs fresh student rollouts through the environment plus teacher queries at each visited history. Microsoft Research and the University of Amsterdam propose reusing pre-collected teacher trajectories instead.
Replayed prefixes: ReOPD samples a teacher trajectory, replays it as a prefix, has the student act at selected steps, and lets the teacher supply dense per-step supervision, with no new environment interaction during student training.
The prefix trap: The paper names a real pathology in multi-turn distillation. Pushing histories toward the studentās own distribution makes them more relevant to the student and simultaneously drags the teacher onto states where its targets are unreliable, a two-sided shift between student occupancy and teacher reliability.
A simple control: Treating this as reliability-aware prefix distribution design, ReOPD uses a step-decaying sampling schedule that emphasizes early, lower-shift prefixes rather than trying to match the student everywhere.
Why it matters: Across math reasoning with Python and search environments, over multiple teacher and student scales, it preserves or improves accuracy, uses zero tool calls during student training, and runs at least 4 times faster per rollout, turning agent-environment interaction into a reusable offline asset.
3. Invisible Reasoning
Chain-of-thought monitoring rests on the assumption that a model expresses its reasoning in its output tokens. This work demonstrates a concrete failure of that assumption in models shipping today.
Filler tokens carry computation: Across 13 frontier models and three tasks, many models improve significantly when given semantically irrelevant filler tokens, with accuracy gains of up to 13 percentage points, and the benefit depends on which tokens are used.
Hidden objectives are reachable: Filler tokens let Claude Opus 4.5 satisfy a hidden modular arithmetic constraint without sacrificing accuracy on its primary task, showing that invisible reasoning can serve goals a CoT monitor never sees.
Training does not induce it: Reinforcement learning gives Qwen3-235B strong preferences over filler token content, but neither RL nor supervised fine-tuning produces a filler token benefit that persists at test time, so this is a property of the frontier models rather than a trick you can bolt on.
Why it matters: If consequential computation already happens with no interpretable trace in the output tokens, then CoT-based oversight is a partial signal, and safety cases built on reading the reasoning need to account for what is not written down.
4. Molt
Agentic RL research is constant algorithm modification, and in mainstream frameworks each change threads through layers of trainer, distributed backend, and rollout glue. NVIDIAās Molt is a PyTorch-native training framework built to make that cost small.
Readable by design: The stated target is a codebase compact and clean enough for a researcher to hold in their head, and for an AI coding assistant to read and reason about in its entirety, so the algorithm flow can be traced and changed end to end.
The agent stays an ordinary program: One asynchronous loop trains multimodal and mixture-of-experts policies while never training on a token it did not generate, staying consistent in tokens, policy versions, and model semantics.
Throughput holds: Under a matched, fully asynchronous protocol, Molt comes out statistically comparable to a state-of-the-art Megatron-based stack, so the simplicity does not show up as a throughput penalty.
Why it matters: Recipes and containers are open source, and the framing is notable on its own. Being legible to an AI coding assistant now sits alongside throughput as a stated design constraint on research infrastructure.
5. JAXBench
GPU kernel optimization has KernelBench to hillclimb on. TPUs had nothing, and the Pallas DSL is documented thinly enough that models mostly guess. Google, with Harvard and UC Berkeley, closes that gap and finds a clean lesson about context along the way.
Built from production workloads: JAXBench holds 50 JAX workloads, 17 production ML operators extracted from MaxText architectures such as Llama-3.1, DeepSeek-V3, Mixtral, Mamba-2, and AlphaFold2, plus 33 operators translated from KernelBench and resized for high TPU v6e MXU utilization.
Measured against experts: Eight of the 17 production operators ship with hand-optimized Pallas kernels from the public Tokamax library, block-size tuned, so agent output gets compared to expert work instead of a naive baseline.
Context beats scale: With Gemini 3 Flash, conditioning on curated TPU documentation raises per-sample correctness from 5.8% to 37.3% and solves 48 of 50 benchmarks at a 1.28x geomean speedup, while Autocompās beam search pushes it to 1.36x and reaches 1.60x on the hand-tuned subset.
Why it matters: Correctness turned out to be a documentation problem and speed turned out to be a search problem, a split that generalizes to any agent working against an API it was never trained on.
6. ACM
Production agents accumulate context every turn. The usual fix compresses on a token threshold and throws the remainder away, so the trigger fires for reasons unrelated to what the agent is working on. Meta and CMU hand the decision to the agent instead.
Context editing as a tool: ACM equips the agent with purpose-built context editing tools, so it decides when to compress, offloads what it drops into an external memory system, and queries that store on demand when it needs the detail back.
Short-term to long-term: The design is modeled on the interaction between short-term and long-term human memory, which turns compression from a lossy truncation into a transfer between two stores.
A post-training pipeline: A post-training pipeline built on high-quality context management demonstrations yields a 27% relative gain on BrowseComp-Plus and closes much of the distance to open-source models roughly 40 times larger, with code, data, and checkpoints released.
Why it matters: Analysis shows effective context management lowers peak token pressure, lets the agent explore longer before running out of room, and produces more consistent solutions across independent trials of the same task.
7. Filesystem Memory Audited
Deployed agents increasingly keep long-term memory as a directory tree of markdown files they read, write, and reorganize with ordinary file tools. Research had mostly designed bespoke memory representations instead, leaving the defaultās two working assumptions untested.
Three roles, one filesystem: The setting is formalized as a management agent that integrates and organizes incoming content, a search agent that answers queries with cited sources, and an execution agent that supplies trajectories distilled into skills, unifying declarative memory and skills in one store.
Organization buys search economy: Across long-conversation benchmarks and embodied tasks, organized stores roughly halve retrieval cost when the material is large, which is a real and measurable win.
Answer quality stays flat: No agent in the study converted organization into better answers, and in the growth study the store degraded for every management agent except the strongest one, so the second assumption does not hold yet.
Why it matters: The tool harness matters as much as the model. Changing the tool set alone reshapes the memory store as strongly as swapping the model, which is a lever most teams currently leave untouched.
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.
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.
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.