AI Agents

This paper argues that existing root cause analysis (RCA) benchmarks are flawed because they only label the final root cause, not the reasoning path. The authors introduce OpenRCA 2.0, a new benchmark with step-wise causal annotations. On this benchmark, they find that while frontier LLMs can guess the correct root-cause service 76% of the time, they can only ground it in a verified causal path 61.5% of the time. Outcome-only evaluation completely misses this critical failure mode.

The NOVA system is an agent harness for evolving the architecture of industrial recommender systems. It goes beyond simple code generation by using a novel 'architecture gradient'—a non-differentiable signal from past changes, diagnostics, and metrics—to guide modifications. A multi-stage verification cascade checks semantics, executability, and performance, pruning invalid candidates early. Deployed in production, NOVA achieved a 54.5% effective pass rate on complex architecture evolution tasks, showing a practical path to automating this expert-level work.

The AgentX paper presents a production-deployed multi-agent system that automates the entire development lifecycle for a large-scale recommender system. It operates in a closed loop: a 'Brainstorm Agent' generates hypotheses, a 'Developing Agent' implements them in production code, and an 'Evaluation Agent' runs A/B tests. Both successes and failures are converted into structured knowledge that a meta-learning layer uses to improve the entire system over time, creating a self-evolving development engine.

RAG systems struggle with facts that change over time, as vector search often retrieves stale and current information with near-identical similarity. This paper introduces MemStrata, a retrieval memory that solves this by maintaining temporal validity. When a fact is updated, a deterministic rule retires the old value in a bi-temporal ledger. On evolving knowledge benchmarks, MemStrata drives the stale-fact error rate to nearly 0%, a failure class standard RAG cannot avoid, while matching RAG's latency.

This paper proposes Knowledge-Based Pull Requests (KPR), a new workflow for integrating agent-generated code across trust boundaries like open source. Instead of reviewing raw code from an external agent, the PR is a 'knowledge package' containing the agent's trace, tests, and human-confirmed intent. A trusted, project-owned agent then uses this package to regenerate the implementation inside the project's environment, ensuring it meets local standards, conventions, and security policies. It separates approving the 'what' from approving the 'how'.

This empirical study on LLM quantization for automated program repair reveals surprising trade-offs. While quantization effectively reduces memory footprint by up to 85%, it can increase both inference time and energy consumption due to suboptimal hardware use. The authors also found that quantized and base models often fix different sets of problems with little overlap, meaning quantization isn't just a degraded version but a behaviorally distinct model. Nearly half of the tested configurations were Pareto-dominated by other options.

Recent work on agent security has focused on 'out-of-band' defenses like reference monitors. This paper warns that evaluating them on static benchmarks is insufficient, as it was for previous in-band defenses. The authors advocate for, and demonstrate, an adaptive evaluation protocol where attacks are designed with knowledge of the defense. They apply this to the Progent system, independently confirming its robustness: the defense held, and a new hand-crafted adaptive attack did not raise success rates.

This work recasts model routing as an agentic learning problem. Traditional routers make a static, one-off classification. The proposed ACRouter instead operates in a continuous loop, using execution feedback to close the 'information deficit.' It accumulates experience about which models perform best on which tasks, enabling it to dynamically learn a routing policy that optimizes for performance and cost. On a new benchmark, ACRouter achieves the lowest cumulative regret, demonstrating its ability to learn from experience.

Developers switching between different coding assistants suffer from 'conversational state drift,' as each tool has its own siloed history. ESAA-Conversational solves this by applying an event-sourcing pattern to chat. It uses hooks to capture all conversational turns into a single, append-only log file (activity.jsonl). From this shared log, it can deterministically project consistent state summaries like handoff.md or tasks.json, providing continuity and shared memory across heterogeneous agents without vendor lock-in.

Long-horizon agents often fail due to unmanaged state changes accumulating in their environment. LemonHarness is an execution framework that provides stability by creating an explicit workspace boundary. All state-changing operations (file writes, dependency installs) are routed through structured tool interfaces, with feedback recorded as observations for the agent. The harness also makes the remaining execution time budget visible to the model, allowing it to adapt its strategy as time pressure mounts.

Following a German court ruling that Google is liable for its AI Overviews, Bruce Schneier argues this is the correct legal framework. The core principle is that an AI agent is an agent of the organization that deploys it. If a company would be liable for inaccuracies written by a human employee, it should be equally liable when an AI generates them. Allowing companies to hide behind 'faulty AI' would create disastrous incentives to replace human professionals with cheaper, unaccountable systems.