AI Agents

This paper addresses the "execution-granularity mismatch" where agent reasoning traces become bloated by step-wise tool calls. It introduces HyperTool, an interface that allows a model to invoke a single, executable code block containing a sequence of tool calls. This folds deterministic subroutines into one model-visible step, cleaning up context and reducing token load. The results are dramatic: on the MCP-Universe benchmark, this architectural change more than doubled the accuracy of Qwen3 models, demonstrating a huge gain from smarter tool abstraction.

The code that connects an agent to its environment—the "harness"—is often complex and manually engineered. This paper asks if the harness itself can be learned. It introduces HarnessBridge, a lightweight, learnable module that acts as a bidirectional adapter. It learns to distill raw observations for the agent and to translate the agent's abstract actions into concrete, executable transitions. Trained on a supervision dataset, HarnessBridge matches or surpasses specialized harnesses on SWE-bench and Terminal-Bench 2.0 while substantially cutting token usage.

Agents often fail to remember user corrections across sessions, a major source of friction. The proposed TRACE system addresses this by compiling user feedback directly into runtime enforcement rules. When a user corrects the agent, TRACE mines the correction, rewrites it as an atomic rule, and adds it to a set of checks that must pass before the agent can complete future tasks. This creates a persistent, user-defined guardrail layer that goes beyond memory retrieval to actively prevent the agent from repeating the same mistake.

This paper delivers an important and skeptical result, questioning the assumption that multi-agent systems (MAS) are inherently better than single-agent systems (SAS). Through rigorous evaluation, the authors show that automatically generated MAS consistently underperform a strong single-agent baseline (Chain-of-Thought with Self-Consistency), despite being up to 10x more expensive. They argue that current benchmarks don't properly test the supposed benefits of MAS, like parallelization, leading to a misleading perception of their advantage. A crucial read before architecting a complex multi-agent solution.

Training the orchestrator in a multi-agent system is a key bottleneck due to high cost and the need for supervision. This paper proposes Orchestration Reward Modeling (OrchRM), a self-supervised framework to solve this. It avoids costly rollouts or human labels by automatically constructing win-lose pairs for reward model training from the intermediate artifacts of agent executions. This enables training an orchestrator up to 10x more efficiently (in tokens) while improving task accuracy by up to 8% on several reasoning benchmarks.

Coding agents are typically stateless, forcing them to re-derive context or repeat failed attempts in each session. PROJECTMEM introduces a local-first, event-sourced memory layer to fix this. It records development work as an append-only log of events like issue, attempt, and fix. This log not only provides compact context to the agent but also powers a pre-action gate that warns the agent before it repeats a known-bad fix. The paper frames this as "Memory-as-Governance," where memory actively guides future actions.

Numerical and financial reasoning is brittle. To improve robustness, MoCA-Agent introduces a novel "market-of-claims" architecture. The system decomposes a question into atomic, verifiable claims. Specialist agents then "buy" or "sell" these claims based on their confidence. A final, executable program is synthesized only from the claims that "clear the market" and pass a code-aware verification step. This structured, claim-level aggregation of evidence achieves strong performance on several high-stakes financial reasoning benchmarks, outperforming unstructured debate-based methods.

Getting Text-to-SQL to work reliably is notoriously difficult. The TAHOE system improves performance by learning from past errors without costly model retraining. It treats prompt optimization as a data management problem, distilling compiler errors into "Syntax Hints" and user feedback into "Semantic Hints." These hints are stored in a structured "Hint Bank" and retrieved at inference time to guide the LLM. On a difficult Spider subset, TAHOE improved GPT-5.5's pass rate from 61.95% to 79.42%, demonstrating the power of this error-driven approach.

This paper argues that existing prompt injection benchmarks are too simplistic, treating attacks as a simple pass/fail. It introduces a new "stakeholder-centric" benchmark for web agents that instead categorizes and attributes the harm of an attack. It distinguishes between consequences for the user, a seller, or the platform itself. This nuanced view reveals that current agents are vulnerable to a wide range of exploit patterns, from "stealthy parasitism" where the user's task still completes, to complete task hijacking. It's an important shift in how we should measure agent security.

This paper presents DIG, a powerful framework for generating proof-of-concept exploits for one-day vulnerabilities. It uses an LLM in a novel two-stage process. First, the LLM analyzes a security patch diff to synthesize an "oracle" program that makes the vulnerability's trigger conditions explicit. Second, this oracle is used to guide another agent in generating the exploit, dramatically narrowing the search space compared to traditional fuzzing. On 138 real-world CVEs, DIG found exploits for 80, outperforming the next best baseline by 40%.

A cautionary postmortem details how an experimental AI agent bankrupted its operator. The agent, tasked with scanning the decentralized DN42 network, got caught in a loop that spun up a massive number of cloud resources, leading to an astronomical bill. The incident is a stark illustration of the risks of deploying agents with access to powerful, expensive tools without rock-solid cost controls, circuit breakers, and fine-grained observability on tool-invoked resource consumption. This failure mode goes far beyond token costs.

Following swift and sharp backlash from developers, Anthropic has apologized for the undocumented "invisible distillation" guardrail in Claude Fable 5. This feature silently degraded model performance on topics the company deemed sensitive, creating an un-observable and non-deterministic failure mode for production systems. The incident underscores a fundamental tension: developers require predictable, transparent behavior to build reliable systems, but model providers are implementing hidden safety mechanisms that undermine that trust. The rapid apology signals the power of the developer community.

Pouring some cold water on the hype, a new analysis from Endor Labs concludes that Claude Fable 5 provides only "mid-tier results" on coding tasks. This independent evaluation serves as a crucial counterpoint to marketing announcements and general-purpose leaderboards. For engineering teams evaluating new models, the report is a reminder that performance is domain-specific, and in-house or trusted third-party benchmarks that reflect actual production use cases are essential for making informed decisions about which model to adopt.

A technically rich blog post provides a from-first-principles walkthrough of building a "vintage" LLM. While not directly focused on building agent systems on top of existing models, it offers a clear look at the fundamental architecture and mathematics that power the tools agent developers use every day. For engineers who prefer to understand the full stack, it's a valuable read that demystifies the components running behind the API endpoints we all rely on.

Simon Willison describes Claude Fable 5 as "relentlessly proactive" in a detailed walkthrough of an agentic debugging session. Starting with just a screenshot of a CSS bug, he shows the model using a sequence of tools to inspect the codebase, read dependencies, and ultimately identify the root cause. It's a compelling, real-world example of a state-of-the-art agent moving beyond simple instruction-following to more autonomous problem-solving on a real codebase, deploying multiple strategies to reach its goal.

In his release notes for Datasette 1.0a33, Simon Willison offers a glimpse into his agent-assisted development workflow. To build a demo tool for the new API, he used two different models for distinct tasks: Claude Fable 5 for high-level planning and GPT-5.5 xhigh for the concrete implementation. This pragmatic use of a multi-agent, multi-model workflow—delegating planning and coding to the models best suited for each—is a pattern many senior developers are adopting for their own work.