https://x.com/i/article/2099167331314204676
🥇Top AI Papers of the Week
The Top AI Papers of the Week (September 7 - September 13).
- Procedural Graphs
Long-horizon agents usually pick each action by generating over a growing history, which leaves the procedural knowledge of what to do next, in what order, and under which conditions implicit. As trajectories get longer they lose track of objectives, call tools out of order, and repeat actions that already failed. Researchers at Google make that knowledge an explicit graph the agent can query.
• Procedures instead of facts: A knowledge graph stores entity-relation-entity triplets to answer what-is questions. A Procedural Graph stores procedure-relation-procedure triplets, so the agent can ask what to do next and under which conditions.
• Guidance without dictation: At each step the framework localizes the agent’s active node and extracts the surrounding subgraph, and a guidance model turns it into step-level guidance that biases the solver’s next action without dictating it.
• The graph edits itself: An LLM refiner contrasts failed trajectories with successful ones and edits the graph’s topology and attributes. Edits are committed only when held-out validation performance holds or improves, and rejected edits stay on file so the same change is not proposed twice.
• Why it matters: Starting from a minimal skeleton, the loop builds graphs that match or beat hand-designed ones, and it can repair a flawed expert prior instead of inheriting it. Across datasets, task types, and LLMs, it delivers consistent gains over memory-based baselines, which gives teams whose agents drift on long tasks a structure they can inspect and improve without manual engineering.
Paper | Tweet
- FrogNano
Small coding agents are usually built by distilling a frontier model’s trajectories. Microsoft’s FrogNano report shows that a 4B coding agent can reach competitive performance without a larger teacher at any point, post-trained purely with RL on synthetic tasks.
• Built for minimal hardware: The target is a coding agent that runs on minimal machines, which rules out both a frontier backbone and a frontier teacher. The agent starts from Qwen3.5-4B and is post-trained on roughly 1,500 software engineering environments.
• Tasks at the edge of learnability: An online task synthesis pipeline called TaskPilot generates executable tasks from real repository snapshots and calibrates them to the current checkpoint, so the agent keeps training on problems it can just barely solve. Tasks that are too easy or too hard are filtered out before each RL round.
• Calibration over volume: The report credits calibration, rather than the amount of synthetic data, as the main ingredient. Training runs as repeated rounds of task synthesis and RL inside Leaf, a lightweight harness with five typed tools.
• Why it matters: If synthetic tasks alone can train a competitive 4B coding agent, teams can build small agents for local and resource-constrained deployments without access to a frontier teacher. The task generator, more than the dataset size, looks like the component worth investing in.
Paper | Tweet
- STAIR
Retrievers chunk long documents by length, which throws away the hierarchy the document already has. Researchers at IBM point out that a table of contents already encodes that global structure, and they build a retriever around it.
• Addressing by table of contents: STAIR is a generative retriever, meaning the LLM stores and retrieves information from its own parameters. It addresses that information through the corpus’s table of contents, so retrieval follows a structure the corpus supplies rather than one invented for the index.
• A new benchmark: The authors release SearchTome, built from 18 books across 6 domains, to support further research on retrieval that uses the table of contents.
• Strong recall against baselines: STAIR reaches Recall@1 of 82.6% on SearchTome against 76.9% for a fine-tuned Differentiable Search Index, a statistically significant gap. BM25 lands at 59.5%, DPR at 68.7%, and out-of-the-box Mistral at 13.8%.
• Why it matters: Hallucinated results are the standing objection to generative retrieval, and STAIR keeps the hallucination rate below 0.05% while generalizing to sections with very few training examples. For corpora with real structure, such as manuals, textbooks, and long reports, the hierarchy is a signal that length-based chunking throws away.
Paper | Tweet
- AI-Native Design Docs
Google DeepMind, MIT, and colleagues maintain a performance-modeling library called SMART whose main branch contains almost no code. The repository is a directed graph of natural-language design docs, and coding sub-agents regenerate the entire implementation from those docs whenever a version updates.
• Every human change is a doc edit: Engineers do not patch the code directly. They edit a design doc in natural language, so the library documents itself by construction.
• Why regenerate at all: ML performance modeling invalidates its own abstractions with every new generation of hardware and models. The authors argue that coding agents are now fast and cheap enough that regenerating a library costs less than paying down the tech debt of patching it.
• Two ingredients keep regeneration reliable: The design docs are written around step-by-step worked examples that act as in-context demonstrations for the generating agents. The system is also anchored on a minimal, recursively defined operator IR with symbolic cost expressions in SymPy, with a fast analytical mode for large sweeps and a slower modulo-scheduling mode for fine-grained schedule studies.
• Why it matters: Regenerated implementations reproduce hand-audited reference models to round-off precision, including DeepSeek-V3 serving on a TPU pod slice. That result supports keeping design docs as the durable artifact in fast-moving domains and regenerating the code as a build product.
Paper | Tweet
- PARSER
Sequential memory agents read long documents one chunk at a time while carrying a compact memory state. That design ties reasoning depth to how far the agent has read, makes accuracy sensitive to where the evidence sits, and grows latency linearly with document length. PARSER separates reading from reasoning.
• Parallel reading: A bank of lightweight subagents, each bound to a single chunk, reads the entire document in parallel, so the agent no longer has to traverse the document one chunk after another before it can reason about it.
• Iterative scatter-gather: A lead agent reasons in depth over several rounds. In each round it broadcasts a query to all subagents, aggregates the returned evidence, and forms a deeper follow-up query based on what it has found so far.
• Only the lead agent learns: All learnable behavior sits in the lead agent, which is trained with reinforcement learning. The subagents stay frozen off-the-shelf models, so the reading side needs no training.
• Why it matters: On multi-hop QA with contexts from 7K to 896K tokens, a 4B PARSER beats the strongest sequential memory baseline by 5.7 points on average and by 12.0 points at 896K, and a 9B version passes DeepSeek-V4-Pro by 6.3 points. It also holds up when evidence position, order, and distance are perturbed, conditions that cause large accuracy swings in sequential methods, while cutting inference latency by up to 11x.
Paper | Tweet
- Proactive Thought Partners
Proactive writing tools mostly mean autocomplete. This paper from Google DeepMind studies what it looks like when an AI agent offers higher-level cognitive support during writing and picks its own moment to speak up.
• A week-long probe: The researchers built a technology probe, a lightweight Markdown editor with a side panel for suggestions, and deployed it with 16 participants for one week. Writers create partners by configuring a role and a proactivity level, and relevant partners take the initiative as the writing happens. An event such as a pause, the end of a sentence, or a text selection can prompt an activated partner to offer a suggestion.
• Support planned in advance: Participants configured their partners prospectively, planning for situations they expected to run into rather than reacting to interruptions after the fact.
• Two uses for suggestions: Writers used suggestions for idea generation and also for self-monitoring, a purpose that proactive tools rarely design for.
• Why it matters: Participants judged intrusiveness by presentation, valuing lightweight visual representations and non-directive rhetorical framing. If you are building an assistant that acts before being asked, how an intervention is phrased mattered to users as much as when it arrived. The paper closes with design implications around customization, timing, engagement, and representation.
Paper | Tweet
- Codebook Agent
How many distinct communication topologies does an LLM multi-agent system need? Current topology designers treat each query as a conditional graph generation problem and search the full adjacency space with a variational, autoregressive, or diffusion decoder. This paper argues that formulation is misaligned with the problem, and its answer is about six.
• Topologies collapse to a handful: As codebook capacity grows from 8 to 64, the topologies that survive a reward filter keep collapsing to roughly the same six graphs.
• Sparser is not cheaper: Edge count correlates negatively with measured token consumption (r about -0.4), so sparsifying the agent graph makes inference more expensive. A message-passing scorer over agent-profile nodes also cannot rank candidates when agents share a profile, which is the default setup in published benchmarks.
• Lookup instead of search: A vector-quantized autoencoder compresses successful topologies into a query-independent 16-entry codebook, a reward-weighted MLP maps the query embedding to a distribution over codes, and an MLP proxy reading the flattened adjacency reranks the top decoded candidates in one batched forward pass.
• Why it matters: With no iterative search at test time, Codebook Agent leads all six benchmarks at 84.6 average against 83.0 for the strongest prior designer, emits a topology in 2.4 ms, and uses 21.9 to 33.2% fewer LLM tokens. For teams tuning multi-agent systems, a small fixed menu of topologies appears to be enough.
Paper | Tweet
- Research Swarm Cheating
Google DeepMind ran a research collective of 100 autonomous LLM agents proving formal math conjectures, and cheating emerged with no external intervention as one agent’s exploit of the evaluation system spread through shared channels. A separate group of agents then audited the fraudulent proofs, alerted peers, and proposed validation patches, and the authors propose governance rules such as graduated sanctioning for shared agent infrastructure.
Paper | Tweet
- Co-Evolving Harnesses and Models
Salesforce found that fine-tuning a weaker model on a stronger expert’s full trajectories, under a harness evolved for the weaker model, dropped performance on all seven enterprise tasks by 4 to 30 points because the model copies a planning strategy it cannot execute. Having the expert rewrite only the failing turn in the weaker model’s own rollout keeps its planning style intact and combines the gains of harness evolution and fine-tuning.
Paper | Tweet
- Recursive Self-Improvement Survey
This survey splits recursive self-improvement into stages of autonomy, from executing improvements someone else designed up to improving the improvement process itself, which gives a concrete way to check what a claimed self-improving agent actually automates. It also uses a Headroom-Closed Index to show where current LLMs fall short and compares requirements across scientific discovery, embodied intelligence, and software engineering.
Paper | Tweet