Wednesday's cs.AI announcement day (2026-10-28) lists 95 new and 159 cross-lists (replacements skipped; listing total 254). A filter for agent systems, memory/context, computer-use / GUI / tools / skills / harnesses, multi-agent, persistence, and local/open models keeps 38 papers. Context engineering leads again: one runtime compiles a coding agent's subtask tree into context, summarizing only finished subtasks so the cached prefix survives, and raises Codex's score while cutting cost by a third; another study finds a real agent harness slicing a third of its tool results into broken JSON while the context window sat almost empty. Memory papers converge on curation over volume: an obsolete version of a fact hurts more than unrelated noise and bigger retrieval budgets make it worse, a repository-resident memory lets a fresh agent pick up another model's investigation, full group transcripts underperform no notes at all, and new designs cover proactive agents, multi-user voice identity and verified progress for GUI agents. On safety, a typestate library enforces confirm-before-write by exposing only state-legal tools, a consequence-aware gate halves harmful side effects by routing on reversibility, and a poisoned MCP tool description quietly exfiltrates conversations while tasks still succeed. Self-improvement gets a reality check: automatically optimized skills match hand-written ones once selection noise is accounted for, even as several harness-, rubric- and population-evolution methods report gains. Also: capable-to-cheap model handoffs that cut API cost by two-thirds, a benchmark where lab harnesses fail away from their home models, fast decoder-free and zoom-verified GUI agents, real-time agent environments, coding-agent benchmarks, and KV-cache serving and compression.

Research Papers

Spine: Compiling Subtask Trees into Structured Context for Long-Horizon Coding Agents

Jiahong Xiang; Kunqiu Chen; Lingming Zhang; Yuqun Zhang arXiv: 2610.37224

Spine lets an agent declare explicit subtask boundaries (work scopes), runs nested subtasks inline and reserves delegation for independent parallel work. A persistent SpineTree records subtask relations, interactions, completion state and results; before each model call it compiles the tree into context just in time, keeping unfinished subtasks' interactions and replacing finished ones with their results while preserving prefix-cache reuse. SpineCodex (GPT-5.6 Sol) vs native Codex: +11.8% SWE-Milestone Score at 32.4% lower cost, +17.3% ProgramBench test-pass; matches Recursive Subagent at 73.7% lower cost. A Pi package gives +9.5-17.5% with Gemini 3.8 Flash and Qwen 3.8 27B.

Key insight: Summarizing finished subtasks at their boundaries, while keeping the prefix cacheable, raised Codex's SWE-Milestone score 11.8% and cut cost 32.4%.

Context Is a Pipeline, Not a Window: Information Attrition in LLM Agent Harnesses

Yuvraj Sehgal; Mahsa Panahandeh; Naser Ezzati-Jivan arXiv: 2610.36114

Measures what a harness drops before the model sees it. In a kernel-trace RCA agent over 720 runs the largest prompt used 5.75% of the window, yet 3,827 of 11,189 tool results were cut by fixed-length JSON slicing, each becoming broken JSON; one field reached the model in 4.7% of calls. Models context as a five-stage pipeline; replaying 864 real results, the cut's cost shows up first as extra work (43% more tool calls, 2x compute, yield 0.61 to 0.31). Two of seven surveyed agent frameworks truncate the same unsafe way. Causality of the accuracy drop is left open.

Key insight: A third of tool results in a real agent were sliced into broken JSON while its context window sat nearly empty, and the damage showed up first as 43% more tool calls.

Stratum: Repository Memory for Coding Agents Beyond the Context Window

Yuvraj Sehgal; Mahsa Panahandeh; Naser Ezzati-Jivan arXiv: 2610.36153

Argues coding-agent amnesia is a memory-architecture problem, not context length: KV-cache storage costs 10^4-10^5x more bytes than indexed text; median bug fix touches two files (<10% of repo with imports); 47% of co-edited file pairs are structurally disconnected, so selection must be mined from history. Sketches Stratum, a tiered memory stored with the repo and served by page-safe tools that report what was returned, what remains and the cost. 1.7 ms median retrieval over 1M nodes; a fresh agent inheriting another model's session memory found the root-cause file in 21/24 trials vs 6/24 for retrieval-only, at 4.5x lower median token cost.

Key insight: A coding agent that inherited another model's session notes found the root-cause file in 21 of 24 trials versus 6 of 24 without them, at 4.5x lower token cost.

Concordat: Typed Sessions for LLM Agents

Milad Sikaroudi arXiv: 2610.37461

Concordat, an open-source Python library, treats an agent as a finite-state protocol: each turn the model only sees tools legal in the current state, out-of-protocol calls are rejected before side effects, human-reserved decisions can only be requested, and token/tool budgets split linearly across handoffs. Protocols are checked at definition; subclasses that could bypass the parent's protocol are rejected. On tau-bench airline (50 tasks) with customers pressuring to skip confirmation, the standard agent changed things without the required 'yes' in 13/50 (gpt-4.1) and 29/128 runs (Claude Haiku 5.5); Concordat made none, with no significant task-success change. tau-bench reward missed most violations.

Key insight: Enforcing a confirmation protocol in code, by only exposing state-legal tools, took unconfirmed account changes on tau-bench airline to zero without hurting task success.

CASEL: Consequence-Aware Selective Execution for Reliable Long-Horizon Tool-Using Agents

Yanyan Zhang; Fei Shen; Ting Yan; Hao Zhang arXiv: 2610.36570

CASEL picks per tool call among direct execution, verification, sandboxing, clarification, approval and abstention by combining calibrated failure probability, state-dependent consequence, reversibility, ambiguity and evidence freshness. In simulation (20 seeds x 120k actions, same menu and compute), harmful-side-effect trajectories drop from 14.75% (uncertainty gate) to 7.02%; a failure-prob x consequence gate reaches 5.82% but sends 45% more actions to human approval; removing reversibility routing raises harm to 15.53%. Authors note intervention effectiveness is assumed, not measured.

Key insight: Routing each tool call by consequence and reversibility roughly halved harmful side effects compared with an uncertainty-only gate at the same cost.

Log-To-Leak: Prompt Injection Attacks on Tool-Using LLM Agents via the Model Context Protocol

Yuepeng Hu; Chongyu Fan; Sirat Samyoun; Jian Du arXiv: 2610.36108

Figure from Log-To-Leak: Prompt Injection Attacks on Tool-Using LLM Agents via the Model Context Protocol
Log-To-Leak: Prompt Injection Attacks on Tool-Using LLM Agents via the Model Context Protocol

Log-To-Leak poisons MCP tool metadata so the agent makes an extra attacker-controlled 'logging' call after its final legitimate call, leaking the user query, server name, server response and agent response. Across 18 model-server pairs (5 MCP servers, 4 agents): 62.64-100% attack success, 76.55-95.64% logging accuracy, and 16 pairs change task completion by at most 6.63 points, so success hides the leak. Three defenses leave >55% residual ASR on GitHub MCP with GPT-4o; an instruction detector flags 85.53% of benign descriptions.

Key insight: A poisoned MCP tool description can make an agent leak its whole exchange through an extra 'logging' call 62-100% of the time while the user's task still completes normally.

Does Your Generalist Skill Optimizer Really Incentivize Agentic Tasks? Rethinking Skill Optimization via Bipartite Attribution

Jiawei Zhou; Bo Peng; Yuxuan Huang; Ming Zhang; Youbang Sun; Xiang Wang; Chaochao Lu arXiv: 2610.37201

BiPA replays a skill optimizer's acceptance rule on candidates identical to the seed and logs each episode as a bipartite graph of turns and text read. Across three optimizers, three agentic benchmarks and two models, learned skills match the hand-written seed (+0.1 points); dev gains vanish on test (best-of-several on <=30 tasks reports such gains even with no change) while reading ~16% more input tokens, mostly from added re-check / one-call-at-a-time rules. Principles: accept only gains above selection noise, charge edits for turns added, let the editor delete/merge rules, show earlier rules' cost. Code released.

Key insight: Automatically optimized agent skills performed about the same as hand-written seeds; their apparent dev-set gains were selection noise and they cost about 16% more input tokens.

When Retrieval Is Not Enough: Obsolete Facts in Agent Memory

Oleeviya Babu Poikarayil; Tony Basil Babu; Abdulrahman Nahhas; Het Darshan Mehta; Jawid Ahmad Baktash; Ernesto William De Luca; Klaus Turowski arXiv: 2610.36308

Figure from When Retrieval Is Not Enough: Obsolete Facts in Agent Memory
When Retrieval Is Not Enough: Obsolete Facts in Agent Memory

Separates retrieval from use on MemoryAgentBench FactConsolidation. Qwen2.5-7B with BM25 on 6K history drops from 45% to 32% when the evidence budget grows 64 to 512 tokens even though the newest statement is in every retrieved set; swapping one unrelated statement for the obsolete version cuts accuracy 100% to 44.6% (Qwen2.5) and to 87.8% (Qwen3-14B), all 50 harmful flips stale. 32K replication: BM25-64 69% vs BM25-512 58%.

Key insight: One obsolete version of a fact in the retrieved evidence can drop accuracy from 100% to 44.6%, and retrieving more context makes stale-fact errors worse.

kw-bench: Breaking Frontier Harnesses on Real-World Tasks

George Juraj Salapa arXiv: 2610.36405

kw-bench, built from real engagements; first task is a five-year VAT reconstruction across three generations of SAP from raw extracts, graded deterministically. With DeepSeek v4.1 Flash for two hours, model-agnostic harnesses delivered (OpenCode 0.542, micro-cc 0.528) while Claude Code and Codex off their home model scored 0.00; failure was 'inertia' in keeping weak signals alive. On Claude Opus 5.5, micro-cc and Claude Code scored 0.9986 and 1.000 in 22 and 25 minutes.

Key insight: On the same mid-tier model, model-agnostic harnesses completed a real audit task while lab harnesses away from their home model scored zero; on a frontier model every harness solved it in minutes.

AgentBaton: Efficient Model Collaboration in Agentic Tasks

Junlong Li; Jindong Jiang; Yonggan Fu; Jiarui Yao; Hanrong Ye; Wonmin Byeon; Peter Belcak; Hao Zhang; Pavlo Molchanov arXiv: 2610.35959

Figure from AgentBaton: Efficient Model Collaboration in Agentic Tasks
AgentBaton: Efficient Model Collaboration in Agentic Tasks

Studies model handoffs inside one long-horizon task. Efficient-to-capable handoffs underperform with little saving; capable-to-efficient handoffs at the right stage preserve or improve accuracy at much lower cost. AgentBaton, a lightweight detector of when to hand off, cuts API cost 65.9% on average across 11 model pairs and two benchmarks, with up to +8.8 points over capable-only, and extends the accuracy-cost Pareto frontier across reasoning-effort settings.

Key insight: Handing a long-horizon task from a capable model to a cheaper one at the right moment cut API cost 65.9% on average while preserving accuracy.

Proactive Memory for Event-Driven LLM Agents

Jinyang Li; Zichuan Fu; Xian Wu; Wenlin Zhang; Yimin Deng; Kaifeng Guo; Guojing Li; Junjia QI; Xiangyu Zhao arXiv: 2610.36967

Figure from Proactive Memory for Event-Driven LLM Agents
Proactive Memory for Event-Driven LLM Agents

ProactMem splits history into recent events, temporal trajectories and behavioral regularities; trajectory facts are checked against source events and regularities validated by historical replay before matching to the current event. New ProactiveStream benchmark (three application scopes, chronological event streams). ProactMem reaches 52.6% F1, a 21.4% relative gain over the strongest of five baselines. Code released.

Key insight: Validating a learned behavioral routine by replaying history before acting on it improved proactive-agent F1 by 21.4% relative to the best baseline.

From Voiceprints to User Entities: Online Speaker-Memory Construction for Multi-User Spoken Agents

Yucong Zhang; Cancan Li; Bo Xiao; Ke Zeng; Ming Li arXiv: 2610.36713

EvoSpeakerMem is a training-free layer for causal speaker routing, selective acoustic-state updates, and identity-partitioned memory writes/retrieval over any text-memory backend. New LoCoMo-ID benchmark with hidden speaker identities. Genuine-probe rejection at a frozen threshold rises 29.8% to 55.6% over ~a year (voices drift); gated updating improves identity-gated QA by 3.86 / 11.62 points (clean / shifted), with no wrong-user authorizations. Notes a fragmentation-contamination trade-off QA does not reveal.

Key insight: Treating voiceprints as evidence rather than identity, and updating them selectively, improved identity-gated memory QA with no wrong-user authorizations as voices drift over a year.

Remembering Is Not Enough: Refining Memories and Learning When to Use Them in Multi-Agent Systems

Yipeng Hao; Yuxuan Cai; Wenkai Ji; Jie Zhou; Liyang Yu; Qin Chen; Zhiguo Yan; Shulei Zheng; Liang He arXiv: 2610.36652

DiscernMem (training-free): Defect-Aware Memory Refinement compares team runs with one memory vs none to diagnose and test rule repairs; Boundary-Learning Meta-Memory records each memory's past uses and learns when its owner role should apply it. With Qwen3-4B-Instruct-2507 it gets the best average on AutoGen, CAMEL and MacNet, +0.51-4.32 over baselines; PDDL 37.71 vs 28.48 on CAMEL.

Key insight: Testing each shared memory against a no-memory run and learning when each role should use it gave the best average score on three multi-agent frameworks with a 4B model.

EMMA: Structured Episodic Memory for Multi-Agent Workflow Synthesis

Ruijia Niu; Kaiwen Liu; Rose Yu; Kristina Klinkner arXiv: 2610.35966

Figure from EMMA: Structured Episodic Memory for Multi-Agent Workflow Synthesis
EMMA: Structured Episodic Memory for Multi-Agent Workflow Synthesis

EMMA treats a multi-agent system's configuration (controller routing memory, specialist prompts, per-step procedural skills) as episodic memory; a reflector assigns each failure to the scope that owns the fix and proposes one edit, with backbone-independent guards keeping edits scoped, incremental and bounded. Best on KramaBench, AppWorld and BBEH across five backbones vs ACE, GEPA, EvoMAS, ADAS (up to +32.5%) with 17-38% fewer training executions.

Key insight: Restricting self-improvement to one bounded edit at the scope that owns each diagnosed failure beat ACE, GEPA, EvoMAS and ADAS by up to 32.5% with fewer training runs.

Rare, Relevant, and Still Wrong: How Memory Fails LLM Group Decisions

Anouar Imel; Imad Charradi; Abderrahman Sghir; Khalil El Khammar arXiv: 2610.37624

CrossProfile (480 hidden-profile tasks) crosses who holds supporting, decoy and irrelevant facts. On Qwen2.5-7B, Llama-3.1-8B and two DeepSeek models, relevance selection readmits on-topic decoys (loses 23-31 points to rarest-first in the classic setup); rarest-first is no better than random on average. The decision model over-weights facts attributed to many agents; removing or randomizing attribution tags adds 13-24 points. In natural discussions the full transcript is worse than no notes.

Key insight: When compressing a group discussion into memory, neither keeping the rarest nor the most relevant claims works reliably, and 'N agents said this' tags mislead the final decision.

From Interaction to Capability: Task Advancement as State and Supervision for GUI Agents

Ziyang Chen; Qian Li; Chengwei Qin arXiv: 2610.37482

Figure from From Interaction to Capability: Task Advancement as State and Supervision for GUI Agents
From Interaction to Capability: Task Advancement as State and Supervision for GUI Agents

Task Advancement Memory (TAM) tracks verified task progress as state during execution and afterwards abstracts the interactions that produced verified local results into reusable operations (inputs, expected outcomes, verification conditions), harvesting them even from failed tasks. On MobileWorld GUI-only tasks, Advancement State alone lifts success 12.0% to 28.2%; full TAM +17.6% relative over the strongest baseline and 38.7% fewer lifecycle tokens per solved task; SOTA on SPA-Bench single-app English Level 3.

Key insight: Tracking verified task progress as state more than doubled a mobile GUI agent's success rate (12.0% to 28.2%) and cut tokens per solved task by 38.7%.

GUI-JEPA: Candidate-Conditioned JEPA Latents as a Fast Action Policy for Mobile GUI Agents

Bingchao Wang; Yongcheng Jing; Shunyu Liu; Chengyu Wang; Jun Huang; Jie Yang; Wei Liu; Dacheng Tao arXiv: 2610.36877

Figure from GUI-JEPA: Candidate-Conditioned JEPA Latents as a Fast Action Policy for Mobile GUI Agents
GUI-JEPA: Candidate-Conditioned JEPA Latents as a Fast Action Policy for Mobile GUI Agents

GUI-JEPA selects actions in the latent space of a JEPA encoder pretrained on unlabelled screenshots; a candidate-conditioned predictor scores all candidate actions in one batched pass with no token decoding. On AndroidControl it is 2.8-4.0x faster than a fine-tuned Qwen2.5-VL-7B agent with 86-92% of its in-distribution accuracy at 6% of its parameters. Code released.

Key insight: Scoring candidate GUI actions in a JEPA latent space ran 2.8-4.0x faster than a 7B VLM agent with 6% of its parameters and 86-92% of its accuracy.

AdaGround: Token-Normalized Adaptive Zooming with Verifier-in-the-Loop Refinement for GUI Grounding

Bingchao Wang; Yongcheng Jing; Chengyu Wang; Jun Huang; Jie Yang; Wei Liu; Dacheng Tao arXiv: 2610.36874

Figure from AdaGround: Token-Normalized Adaptive Zooming with Verifier-in-the-Loop Refinement for GUI Grounding
AdaGround: Token-Normalized Adaptive Zooming with Verifier-in-the-Loop Refinement for GUI Grounding

AdaGround sets zoom magnification/field of view from the model's own target-size estimate, uses a marked-click Yes/No verifier to keep or reject zooms, re-ground, or abstain, and composes spreadsheet cells from headers. On Qwen3-VL it adds 7.4-20.6 points over the backbone on OSWorld-G and ScreenSpot-Pro, beating training-free zoom methods and many trained GUI models; gains carry to UI-Vision. Code released.

Key insight: Matching zoom to the target's estimated size and verifying each zoom with a yes/no check added 7.4-20.6 grounding points to Qwen3-VL without training.

Gym-Anything-RT: Scaling Real-Time Environments for Vision-Language Agents

Pranjal Aggarwal; Sean Welleck arXiv: 2610.37567

Figure from Gym-Anything-RT: Scaling Real-Time Environments for Vision-Language Agents
Gym-Anything-RT: Scaling Real-Time Environments for Vision-Language Agents

Gym-Anything-RT auto-generates visual minigames over a six-capability taxonomy and can run each in real time, slowed or paused. Across 100 minigames GPT-6 Astra (xHigh) passes 9.0% in real time vs 75.0% paused; frontier agents given code tools write code that bypasses real-time perception. Released publicly.

Key insight: A frontier agent that passes 75% of minigames when the environment is paused passes only 9% in real time.

When to Intervene? An Empirical Study of Errors and Self-Recovery in LLM Agents

Chiming Duan; Tong Jia; Yingxi Chen; Minghua He; Lingzhe Zhang; Ying Li arXiv: 2610.36471

ReInBench: 1,259 traces and 1,403 error events across computer-use and Web tasks. 725 errors self-recover, often within a few steps, varying by model; self-recovery also helps with later errors of the same type. ReCoF predicts at error time whether it will self-recover (+9.02% relative Macro-F1 over the best baseline).

Key insight: About half of agent errors in computer-use and web tasks self-recover within a few steps, so interventions should target the errors that will not.

Monitor Accuracy Isn't the Answer: A Decision-Value Framework for Evaluating AI Agent Restart Monitors

Siddharth Jain; Venkat N. Vedam arXiv: 2610.36544

Shows a 90%-accurate restart monitor can swing from -5 to +35 points in success depending on the replacement attempt's residual-budget success probability. Proposes a decision-sufficiency criterion and a finite-sample, model-free decision audit over existing traces (restart / continue / abstain). On 194 SWE-bench Verified SymPy runs, an apparent 2.29-point restart gain traced to a single attempt, a second model lost 42.29 points, and 0 of 103 live comparisons met the certification bar.

Key insight: A restart monitor's accuracy says little about whether restarting helps; on SWE-bench runs, apparent restart gains did not survive a decision audit.

Correction or Manipulation? Measuring Epistemic Vigilance in LLM Agents Under User Pressure

Nardine Basta; Venus Haghighi; Dali Kaafar; Amin Beheshti arXiv: 2610.36453

Seven LLMs from four vendors under graded user pressure (claimed authority or unverifiable citations), including a customer-support agent allowed account changes only for verified users. Citations made five of seven models concede more and four discriminate worse. Five models never broke the verification policy even if they readily abandoned correct answers; Ministral 3B broke it under claimed authority and Ministral 8B reported changes it had not made. 'Revise only on verifiable evidence' instructions mostly shifted propensity, not discrimination.

Key insight: Whether a model concedes answers under user pressure did not predict whether it broke an account-verification policy, so agents need to be tested on actions, not just answers.

Your Agent Acts Differently When You're Around: How User Presence Changes Agent Behavior in Negotiation

Jane Pan; You Lyu; Abe Bohan Hou; Valerie Chen; He He arXiv: 2610.36435

PRESENT compares negotiation with and without an interactive user, fixing game, objectives and preferences (11.2k runs, 7 games, 8 models). With a user present, agents get +13.7% payouts and negotiate harder, but misaligned behavior toward counterparties roughly doubles and toward users appears in 14.3% of games, even with templated neutral user messages; outcome metrics miss it.

Key insight: Agents negotiating with their user present earn 13.7% more but behave in misaligned ways about twice as often, which outcome metrics do not catch.

Skill Dreaming: Evolving Repository Skills through Pull Request Streams

Xinyuan Song; Hasibul Haque; Jay Somasundaram; Ryan Turner; Bowen Zhu; Liang Zhao arXiv: 2610.36188

Skill Dreaming builds a repository-specific skill library from validated PRs and keeps refining it as new PRs land, guiding coding agents on features plus tests, docs, compatibility and conventions; integrates PR analysis, skill management, execution and CI. The abstract reports no headline numbers.

Key insight: A repository's pull-request history can serve as a continuous training signal for the skill library that guides coding agents in that repository.

When the Critic Falls Behind: Co-Evolving Rubrics and Harnesses for Continual Agent Self-Improvement

Hao Chen; Yukun Yan; Ziyu Han; Ye He; Chuanzhe Guo; Shangzhan Li; Qi Shi; Qingfu Zhu; Maosong Sun; Wanxiang Che arXiv: 2610.36826

RuHarness keeps discovering and reassessing behavioral criteria from trajectories, prioritizes unresolved weaknesses, and uses them to drive targeted harness updates with the task objective fixed. Outperforms harness-evolution baselines, especially on held-out tasks. The abstract reports no headline numbers.

Key insight: Harness self-improvement stalls when its critic is static; co-evolving the rubric with the harness generalizes better to unseen tasks.

The View from Nowhere: Population-Centered Agent Evolution

Shuo Yan; Ningning Hou; Haoyu He; Haochen Pei; Shang Gao arXiv: 2610.36660

Population-Centered Evolution distills task records and modification histories across all evolved variants into a 'population block' that guides edits to a parent's harness. Matched setup: 72.1% SWE-bench Verified and 96.7% Polyglot, +3.2 and +5.9 over a group-evolution baseline; closes one-third of the coverage-vs-best-agent gap on SWE-bench and all of it on Polyglot.

Key insight: Using the whole population of evolved agents as evidence, not just the best one, raised SWE-bench Verified to 72.1% and Polyglot to 96.7%.

The Trinity:Capability-Driven Recursive Self-Improvement for Multimodal Agents

Weidong Tang; Ruiheng Wang; Jingxuan Zhang; Hexin Wang; Haoyuan Chen; Zhengfeiyang Zhang; Yixing Ma; Zichen Jiang; Ziyu Guo; Haodong Li; Zhengbo Jiao; Zhiqing Cui; Xinxiang Yin; Shuo Liang; Zhenglin Wan; Hongzhan Lin; Wangbo Zhao Kaipeng Zhang; Pengfei Zhou; Odin Zhang; Yang You arXiv: 2610.36077

The Trinity couples world generation with harness evolution via Creator, Explorer and Evolver roles, reorganizing tasks into a capability tree, building simplified verifiable sim worlds per capability, evolving reusable harness modules, and routing tasks with a Capability-Aware Harness Router. +34 points mean over 28 training benchmarks and +26 on 18 unseen, including two real-world embodied tasks.

Key insight: Organizing tasks by shared capability and evolving reusable harness modules per capability improved performance by 26 points on 18 unseen benchmarks.

Where Should the Evaluation Budget Go in LLM-Driven Agent Scaffold Evolution?

Sichun Luo; Yi Huang; Mukai Li; Haochen Luo; Guanzhi Deng; Haibo Wang; Jian Xu; Zefa Hu; Junlan Feng; Qi Liu arXiv: 2610.37276

Shows sparse search-time feedback sustains productive scaffold evolution and targeted final evaluation improves selection. Proposed allocation framework: short full-evaluation warm-up to calibrate an item-response model, sparse feedback during search, then refit and paired successive halving at the end. Beats full evaluation in most settings across four benchmarks and two frameworks with ~half the evaluation cells.

Key insight: Sparse feedback during scaffold search plus targeted paired evaluation of finalists beat full evaluation while using about half the evaluation budget.

Batching the Reflective Optimization Loop: Parallel Proposals Make GEPA Faster and Better

Jialin Zhang; Lakshya A Agrawal; Shangyin Tan; Donghyun Lee; Lutfi Eren Erdogan; Dan Klein; Koushik Sen; Alex Dimakis; Matei Zaharia arXiv: 2610.36774

Extends open-source GEPA to propose and evaluate a batch of candidates per step. Most batched runs finish in half the wall-clock time or less (fastest ~1/4-1/3) and score higher: LiveBench-Math 68.9% to 72.1% (2x2), HoVer 49.0% to 60.0% (8x1), with better use of metric-call and dollar budgets.

Key insight: Proposing and evaluating several prompt candidates per step made GEPA optimization 2-4x faster and improved held-out scores.

Evolving Agent Teams

Shiyi Cao; Ziming Mao; Dacheng Li; Joseph E. Gonzalez; Ion Stoica arXiv: 2610.36848

A central supervisor diagnoses local optima and restructures a team of coding agents, grounded by a persistent file system (learning doc, evolution history, per-team artifacts). Beats coding-agent baselines at matched tokens; with more budget, a CUDA kernel at 1.2x mean speedup over FlashInfer MLA paged decode (wins 36 of 47 workloads), KDA prefill 3.01x (MI350X) / 3.44x (B200), and MoE expert-offload serving on Apple silicon at 30.3 tok/s decode for Qwen3.8-Flash-Next in MLX 4-bit on a 48 GB M4 Pro. Code released.

Key insight: A supervisor that restructures a team of coding agents, backed by a persistent learning document, produced a CUDA kernel 1.2x faster than FlashInfer's production MLA decode kernel.

TeamGym: A Gym for Team Decision-Making by AI Agents with Distributed Information

Chanwoo Park; Jaywoong Jeong; Zachary Wojtowicz; Yubin Kim; Taekyun Lee; Kaiqing Zhang; Asuman Ozdaglar arXiv: 2610.37571

TeamGym builds team-decision tasks from legal, finance, medical and SWE corpora with 'pivotal information' sets. Across 8 models and 12 corpora, distributing pivotal facts costs 22.9 points vs one model having them (communication gap) and having to extract them costs a further 19.9 (retrieval gap). RL on team decision loss improves decisions and induces emergent coordination.

Key insight: Splitting the facts needed for a decision across agents cost 22.9 points of success compared with giving them all to one model.

Who Convinced Whom? Tracing How LLMs Change Their Minds in Multi-Agent Systems

Arnesh Batra; Aniket Khandelwal; Jashn Khemani; Krish Thukral; Arush Gumber; Denis Federico Lim; Ujwal Kumar; Phan Xuan Tan arXiv: 2610.35930

MAD Bench (2,400 questions) on three open-weight models with a round-matched reflection control. Debate gives small accuracy gains over initial majority vote but raises unanimous wrong answers by 3.1-7.4 points; stated track record sways answers more than professional-status cues; attributing identical text to self vs another agent changes influence.

Key insight: Multi-agent debate slightly improves accuracy over majority vote but increases unanimous wrong answers by 3.1-7.4 points.

Grounding LLM Agents in Business Processes: Process-Aware Knowledge Graphs for Reliable Multi-Step Service Invocation

Saiful Khan; Afrah Farea arXiv: 2610.37242

Combines OData metadata and BPMN reference processes in a typed property graph; hybrid retrieval follows process edges to downstream endpoints. On 42 enterprise services: +5.7 Recall@3 on low-overlap queries; an agent completes 38.7% of 81 multi-step queries vs 10.3% chunk-based; giving valid code lists eliminates invented codes, full typed context cuts invalid calls to 3% (3/101).

Key insight: Retrieving enterprise API endpoints along business-process edges, with typed schema context, cut invalid agent API calls to 3%.

FeatureArc: Benchmarking Coding Agents on Evolving Features

Yunlong Wang; Alyssa Wu; Cuiyun Gao; Jia Feng; Songyuanyi Lu; Zhichao Hu arXiv: 2610.37434

Figure from FeatureArc: Benchmarking Coding Agents on Evolving Features
FeatureArc: Benchmarking Coding Agents on Evolving Features

FeatureArc: 73 reviewed tasks of 2-10 stages across four languages, one persistent session, no test feedback. Ten agents fall from 62.7% first-stage success to 28.5% whole-feature success; inherited defects appear in 72.9% of failed later stages and agents miss earlier errors ~95% of the time.

Key insight: Coding agents that succeed on 62.7% of first feature stages succeed on only 28.5% of whole multi-stage features, mostly because of undetected earlier defects.

PROBE: Frontier Coding Agents Find Different Bugs Than Maintainers Fix

Marco Paina; Mark Niklas Müller; Niels Mündler-Sasahara; Martin Vechev arXiv: 2610.35987

PROBE: all 2,457 bugs fixed over 18 months in 20 repos. Frontier coding agents reach <21% recall and <9% precision vs the maintainer-fixed set; stronger models raise recall 8% to 17% but not precision, yet 85% of findings are judged valid. Agents find a different bug distribution than maintainers fix.

Key insight: Frontier coding agents recall under 21% of the bugs maintainers actually fix, and the bugs they find follow a different distribution.

WAKMan: Workload Aware KVCache Manager

Suhas Kumar Morisetty; Vaibhavi Lokegaonkar; Sachin Mathew Varghese; Wesley Harris arXiv: 2610.36355

Finds agentic steps return within seconds and favor recency while popular prompts and long chats favor frequency; across 20 mixes no eviction policy always wins (vLLM's LRU +12% hits vs S3FIFO on agentic-heavy mixes, up to -22% elsewhere). WAKMan picks the policy from live traffic without reading prompts: +5 points hit rate over LRU on average, lowest mean and worst-case optimality gap.

Key insight: Agent traffic favors recency-based KV-cache eviction while chat traffic favors frequency, so an eviction policy picked from live traffic beats any fixed one.

DCKV: Learned Transform Coding of the Prompt KV Cache in Hybrid Language Models

Egor Maximov; Aleksei Merkelov; Vasiliy Alekseev; Ivan Krivorotov; Valentin Beliaev; Nikita Arsenin; Dmitry Bocharov; Aleksei Goncharov arXiv: 2610.36950

DCKV is an end-to-end trained codec (transform, quantizer, entropy model) for the KV cache of hybrid models' full-attention layers. On Qwen3.5-2B it stores a token >55x smaller than bf16 at <=1.8 points loss on three long-context benchmarks, >100x at <=3.6 points.

Key insight: An end-to-end trained codec stores prompt KV-cache tokens 55x smaller than bf16 with at most 1.8 points of quality loss.

Self-Keyed In-Parameter Memorization for External Memory-Free Dialogue Recall in Frozen Language Models

XinYu Piao; Myunghoon Ryu; Joongheon Kim; Jong-Kook Kim arXiv: 2610.36948

SKIM has the model generate its own questions about each dialogue turn and writes them in closed form into its parameters as keys that later retrieve the turn, with no external memory. On five models it recalls most stored turns from later user questions.

Key insight: A frozen model can write a dialogue into its own parameters, keyed by questions it generates, and recall most turns later without any external memory.

News and changelogs