AI Agents

PolicyGuard is a sub-agent verifier designed to ensure LLM agents adhere to complex, multi-turn policies. Unlike simple argument-level guards, it shares the agent's full dialogue context, reasons over the policy, and provides corrective feedback for the agent's next turn. On the tau^2-BENCH airline benchmark, this dialogue-grounded approach improved policy adherence by up to 12 percentage points across three major model vendors, while blocking actions half as often as simpler methods.

This paper rigorously studies "regression accumulation," where coding agents break previously working functionality over multi-turn conversations. On a custom benchmark derived from HumanEval+ and MBPP+, the authors find that 40% to 73% of tasks lose correct behavior over an 8-turn interaction. A manual analysis of failures identifies "Cross-Turn Conflict" as the primary cause. The proposed "Verification Gate" — which reruns prior tests and triggers a rollback-retry loop on failure — is the only mitigation that consistently improves performance across all models.

This work formalizes agent memory retrieval as a semantic cache replacement problem and delivers a surprising finding: for semantic workloads, classic heuristics like LRU and LFU consistently underperform a naive FIFO baseline. The authors attribute this to the absence of temporal or frequency locality in semantic retrieval. They propose SOLAR, a learning-augmented framework with theoretical guarantees that achieves a 5–75% relative improvement over FIFO on tight cache sizes by better deciding when and what to evict.

The Self-GC paper reframes context management not as simple pruning but as garbage collection for structured context objects. Instead of just dropping old tokens, it treats user turns, tool outputs, and skill states as indexed objects. A side-channel planner then proposes fold, mask, and prune actions on these objects. Deployed in production, this system reduced daytime average input tokens by 10-15%, demonstrating a viable alternative to simple chronological or heuristic-based context truncation.

This paper diagnoses why recurrent memory agents degrade over long contexts: the problem isn't capturing information, but retaining it. Monolithic memory blocks force every update to risk overwriting existing state. The proposed solution, Multi-Head Recurrent Memory (MHM), partitions memory into independent heads and updates only one at a time, architecturally protecting the others. A simple, training-free MHM-LRU variant improves memory retention on RULER-HQA from under 30% to 74% at ~900k tokens.

Simon Willison shares a practical tip from the Claude Code team: let advanced models like Fable use their own judgment rather than prescribing rigid rules. For example, instead of dictating when to run tests, tell it to decide for itself. This extends to cost management; he shows the prompt and resulting memory file from instructing an agent to delegate smaller tasks to lower-power sub-agents, a concrete pattern for hierarchical agent control.