Papers

Chuning Zhu, Eva Xu, Jose Barreiros et al.

Reasoning for robot control can be learned by treating it as variational inference over a latent space, allowing policies to adaptively allocate computation at test time while maintaining spatial understanding needed for precise physical actions.

This paper introduces Latent Memory Palace (LMP), a method that enables control policies to reason adaptively by organizing information in a learned latent space. Rather than reasoning in language, the approach uses variational inference to create an interpretable, memory-palace-like structure where the policy retrieves information iteratively.

Yifan Wu, Lizhu Zhang, Yuhang Zhou et al.

Active memory management—deciding *when* to remind an agent about past information—outperforms passive retrieval and improves long-horizon task performance by 6-8% across benchmarks.

This paper tackles 'behavioral state decay' in long-horizon tasks—where important information gets buried in expanding context windows. Instead of passive memory retrieval, the authors propose a separate memory agent that actively monitors trajectories, maintains a structured memory bank, and selectively injects relevant reminders into an action agent's decision-making.

Harrison Rush, Vincent Davis, Simone Antonelli et al.

Graph RL with action masking and curriculum learning can solve real-world network optimization problems better than heuristics, and this approach is now live managing millions in Bitcoin transactions.

This paper solves the problem of optimizing liquidity placement in Bitcoin's Lightning Network using deep reinforcement learning. Given a budget, nodes must decide which payment channels to open to maximize routing capacity. The authors train a graph neural network agent with PPO to select the best k channels, using a curriculum that prevents the model from simply copying hub nodes.

QiHong Chen, Aaron Imani, Iftekhar Ahmed

Procedural similarity—finding functions that solve problems the same way—is a powerful but overlooked retrieval signal for code generation that works better than traditional lexical or semantic matching alone.

ProjAgent improves repository-level code generation by retrieving functions with similar procedural logic, not just similar keywords or structure. It breaks down target functions into reasoning steps, finds repository functions that follow similar procedures, and combines this with semantic search and compiler feedback to generate better code.

Shilin Ou, Yifan Xu, Luyao Zhang

Evaluating trustworthy AI agents in real-world systems requires measuring multiple dimensions beyond task performance—including physical safety, fairness, and auditability—and building in transparent oversight mechanisms that log all interventions.

SolarChain-Eval is a benchmark for testing AI agents in decentralized energy markets, measuring both how well they perform economically and whether they behave safely and fairly. It uses physics rules to prevent agents from exploiting invalid data, and includes an AI auditor that reviews risky decisions.

Xiaoshuai Song, Liancheng Zhang, Kangzhi Zhao et al.

For complex research tasks, recursive multi-agent delegation with shared process experience outperforms both single agents and flat multi-agent systems by handling depth and breadth simultaneously.

WebSwarm is a multi-agent framework that orchestrates recursive web search by dynamically decomposing tasks and delegating them across specialized agent nodes. Each node decides whether to search directly or spawn child nodes, enabling deeper and broader information gathering than single-agent systems while sharing experience across similar subtasks.

Eugene Ng Yi Sheng, Bingquan Shen

Mediation mechanisms can help multi-agent systems resist market collapse from self-interested behavior and coordinated attacks, though no mechanism is unbreakable—the key is recovery resilience.

This paper studies how formal mechanisms (like mediation) help groups of self-interested AI agents maintain stable markets and trade fairly. Using 18 LLM agents in a simulated marketplace, researchers tested eight different mechanisms against increasing numbers of disruptive agents and adversarial attacks, finding that mediation works best and can recover even under sustained attack.

Ying Chang, Jiahang Xu, Xuan Feng et al.

When optimizing agents through reflection, extracting causal root causes from execution traces—rather than using raw or naively truncated traces—significantly improves learning efficiency and prevents overfitting to low-value failures.

This paper presents STRACE, a framework that helps LLM-based agents learn from their failures more effectively. Instead of using raw execution traces directly, STRACE filters out redundant failures at the batch level and identifies causally important steps within each trace, creating cleaner optimization signals for agent improvement.

Victor Giannakouris, Immanuel Trummer

LLMs can synthesize database-specific file readers from documentation, enabling direct storage access that bypasses driver overhead—a practical way to escape vendor lock-in and accelerate analytical workloads.

Jailbreak uses LLMs to automatically generate code that reads database storage files directly, bypassing slow database drivers. By analyzing database source code and documentation, the system synthesizes custom readers that convert PostgreSQL and MySQL data into in-memory columnar formats, achieving up to 27x faster analytics without modifying the database.

Yujiao Chen

Deployment rules causally shape multi-agent AI safety as much as model choice does.

This paper introduces institutional red-teaming, a method to test how deployment rules (not just AI models) affect multi-agent safety.

Tianming Sha, Yue Zhao, Lichao Sun et al.

For building reliable autonomous agents, having a large, source-grounded skill library with quality verification is critical—SkillCenter provides 216K+ skills where every claim traces back to its original source.

SkillCenter is a massive open library of 216,938 structured skills for AI agents, with over 114,000 skills verified against peer-reviewed sources and technical documentation. The system uses an LLM-based quality filter and source-grounding to ensure each skill's claims are traceable to exact quotations, helping agents execute tasks that are not just runnable but correct, secure, and maintainable.

Chase McDonald, Nathan Tsang, Wesley N. Kerr

This environment offers researchers a reproducible, computationally efficient testbed for developing and evaluating RL algorithms in strategic games with hidden information and cyclic non-transitive dynamics—properties common in real-world competitive scenarios.

FootsiesGym is an open-source environment for training AI agents in a simplified 2D fighting game with imperfect information and strategic complexity. It provides a fast, accessible benchmark for studying two-player competitive interactions where neither player has complete information, enabling efficient reinforcement learning research on standard hardware.

Yaqi Wu, Xiaolei Guo, Chenyu Zhou et al.

Learning to control *when* and *how* to retrieve (not just what to retrieve) significantly improves multi-hop QA—showing that smart operation selection beats simply retrieving more documents.

DynaKRAG learns when and how to retrieve evidence for multi-hop question answering by treating retrieval as a control problem. Instead of following fixed pipelines, it dynamically chooses between operations like retrieving new documents, reformulating queries, or judging if enough evidence exists—based on what's currently known.

Wenhao Li, Xueying Jiang, Quanhao Qian et al.

Robot policies can achieve view robustness without camera calibration by learning to predict both action in camera space and camera-to-robot geometry, making deployment more practical when camera positions vary.

This paper introduces CamVLA, a robot vision-language-action model that learns to figure out camera positioning automatically instead of requiring explicit calibration. By predicting both camera-relative actions and the geometric relationship between camera and robot, the model works with any camera setup without needing depth data or prior calibration.

Jacky Kwok, Shulu Li, Pranav Atreya et al.

Using continuous probability-based scores instead of discrete LLM judgments improves verification accuracy and calibration, and these fine-grained signals can guide both solution selection and reinforcement learning training.

This paper introduces LLM-as-a-Verifier, a framework that uses language models to evaluate solution correctness by computing probability distributions over scoring tokens rather than discrete scores.

Haozhe Wang, Weijia Feng, Jinpeng Yu et al.

Visual generators need to learn *when* to search for external knowledge, not just *how* to use it—and this knowledge boundary is discoverable through co-training, not fixed in advance.

This paper identifies a critical gap in visual generators: they confidently create incorrect images for requests about new entities, trending topics, and post-training events. The authors show that naive search-augmentation fails because generators have an evolving 'knowledge boundary'—a threshold between what they learned and what needs external context.

Juanwu Lu, Junyu Zhu, Ziran Wang

You can build controllable traffic simulators that stay realistic while letting engineers adjust specific behaviors—like making agents safer or faster—without the model gaming the reward system.

This paper presents CNeVA, a framework for creating realistic traffic simulation agents that can both imitate real driving behavior and be steered along interpretable dimensions like speed or safety.

Jiale Amber Wang, Kaiyuan Wang, Pengyu Nie

Existing test generation benchmarks don't verify if tests actually run or match code changes; this benchmark solves that by grounding evaluation in real executable environments and commit history, revealing that state-of-the-art agents still struggle on recent tasks.

TestEvo-Bench is a benchmark for evaluating AI agents on test and code co-evolution tasks—writing new tests for code changes and updating failing tests. Unlike static benchmarks, it uses real commits from Java projects with executable environments to measure pass rates, coverage, and mutation scores.

Vivienne Ming

Human-AI collaboration success depends on specific collaborative traits (perspective-taking, intellectual humility, curiosity) rather than cognitive ability or model benchmarks.

This study examines when pairing humans with AI improves forecasting accuracy using real-money prediction markets as an objective benchmark.

Zhilin Wang, Han Song, Runzhe Zhan et al.

Autonomous policy improvement requires agents to discover task-specific mechanisms and efficiently convert feedback into parameter updates under constrained budgets—not just win individual tasks.

EvoPolicyGym is a benchmark for evaluating how AI agents autonomously improve executable policies through iterative editing and feedback.

Achint Mehta

For agentic code generation, invest in reasoning capability and effort rather than external tools—stronger models and higher reasoning settings prevent failures at their root, while testing tools don't catch the reasoning errors that actually cause failures.

This study evaluated 90 runs of an agentic coding assistant building the same application, testing whether extra tools and prompts improve code quality. Results show that increased reasoning effort (not testing tools) dramatically improved first-try reliability, raising perfect runs from 28% to 89%, while a testing tool added 42-68% cost with no functional benefit.

Yuquan Xue, Le Xu, Zeyi Liu et al.

Using a world model trained on real robot data to generate synthetic transitions—combined with careful sample selection—lets robots learn manipulation tasks with 59% fewer real interactions while improving success rates by 28%.

WorldSample combines real robot interactions with a world model to generate synthetic training data for reinforcement learning. By closing a loop between physical rollouts, synthetic data generation, and policy improvement, it reduces the number of costly real-world interactions needed while maintaining high-quality learning.

Boyang Sun, Jiajie Li, Yung-Hsu Yang et al.

Robots can learn intent-aware camera control from passive human video by mining supervision pairs of language descriptions, observation changes, and target poses—turning everyday egocentric footage into training data for active perception.

This paper tackles language-conditioned camera motion for robots by learning from egocentric video. Given an image and natural language intent, LIME predicts the next camera pose by combining observation-gain prediction with flow-matching, enabling robots to actively position cameras for inspection, occlusion handling, or user-intent-driven viewing.

Thomas Winninger

Constraining coding agents through simple, language-level restrictions is more effective and cheaper than complex oversight frameworks—the same techniques that manage human engineering teams work better for AI agents.

This paper shows that applying traditional software engineering practices—access control, network policies, and coding conventions—to AI coding agents makes them safer and easier to oversee than using complex scaffolding.

Minghan Yu, Youran Sun, Chugang Yi et al.

Combining supervised retrieval scoring with zero-shot LLM reasoning can dramatically improve dataset discovery—achieving 5x better recall through score fusion and an additional 28% improvement through agentic reranking without extra training.

This paper presents an agentic search system that helps geoscience researchers find relevant datasets and tools from NASA's Earth Observation Knowledge Graph using natural language queries. The system combines supervised neural retrieval with LLM-based reasoning to significantly improve search accuracy, and includes a new benchmark of 47k query-dataset pairs for evaluation.

Lourdes Moreno, Paloma Martínez, Marco Antonio Sanchez-Escudero et al.

Multi-agent systems with internal quality signals and intelligent routing can outperform single-model approaches for text simplification tasks, even when adding lexical resources doesn't improve automatic metrics.

This paper presents three automatic systems for Spanish Easy-to-Read translation, submitted to a shared task. The best approach uses a multi-agent workflow combining two language models with quality signals and intelligent routing to simplify text while maintaining meaning. Results show this guided multi-agent approach outperforms simpler baseline methods.

Uwe M. Borghoff, Paolo Bottoni, Remo Pareschi

Hardware-enforced coordination can provide hard safety guarantees for autonomous systems by implementing coordination rules at the FPGA level, separating deterministic interaction management from adaptive AI reasoning.

This paper proposes using FPGAs to enforce safety-critical coordination rules directly in hardware for autonomous systems that combine AI models with real-time control. By moving coordination logic from software to hardware, the system guarantees deterministic timing and verifiable safety constraints while keeping AI reasoning flexible.

Batu Guan, Zirui Wang, Shaohua Li

AI agents can generate compiler optimization patches, but they typically optimize only the reported case rather than generalizing to all similar cases like human developers do—a gap that retrieval-augmented techniques can partially close.

This paper studies how well AI agents can patch compiler optimizations that were missed by LLVM. The key finding is that agents struggle to generalize patches beyond the specific reported case—they often fix the example but fail to cover all similar cases that developers would handle.

Shengguang Wu, Hao Zhu, Yuhui Zhang et al.

Memory management is a high-leverage, independently trainable skill for LLMs on long-horizon tasks—optimizing it alone can match frontier models' performance without modifying task-solving capabilities.

This paper treats memory management as a learnable skill for language models, similar to how humans develop expertise in organizing and retrieving information. The AutoMem framework automatically optimizes both the memory structure (file schemas, prompts) and the model's ability to use it, achieving 2-4x performance improvements on long-horizon tasks without changing the core task behavior.

Chenyang Ma, Yue Yang, Radu Corcodel et al.

Progress signals and semantic subtask grounding are critical for long-horizon bimanual manipulation—the model predicts both actions and continuous progress to automatically transition between assembly steps and reduce compounding errors.

FurnitureVLA tackles real-scale bimanual robot furniture assembly using vision-language-action models. The system combines a VR teleoperation interface for data collection, a simulation pipeline for training, and a progress-aware model that predicts both actions and assembly progress to handle long-horizon tasks (up to 1550 steps).

Zhi Chen, Zhensu Sun, Yuling Shi et al.

Performance-optimization benchmarks for coding agents have significant reliability issues: reference patches are unstable across machines, scoring rules heavily influence rankings, and most tasks are already solved by existing submissions, making leaderboard positions unreliable indicators of tru...

This paper audits three major benchmarks for evaluating coding agents on performance optimization tasks.

Austin McDannald, Julia Tisaranni, Howie Joress

Constraint programming can optimize experiment scheduling in autonomous labs by finding time-minimal plans that respect hardware constraints, with status dependencies ensuring robust real-world execution.

This paper tackles how to efficiently schedule experiments in autonomous labs when multiple instruments have different speeds and capacities. The authors use constraint programming to find optimal schedules that minimize total time while respecting hardware limits, then add a dependency system to ensure reliable execution of those schedules.

Sergio Hernández-Gutiérrez, Matteo Merler, Ilze Amanda Auzina et al.

Simple prompting baselines outperform recent dense supervision methods, and you can now evaluate supervision signal quality before training by checking if scores align with reference Q-values—saving significant compute.

QVal is a training-free evaluation framework for comparing dense supervision signals used in long-horizon LLM agents.

Xinyu Zhao, Zhen Tan, Vaishnav Tadiparthi et al.

Instead of treating skill selection as separate retrieval and ordering problems, jointly predicting skill sequences as a single structured decision improves agent performance and reduces token costs.

This paper tackles how LLM agents should select and order skills (reusable procedural knowledge packages) when solving complex tasks. The authors propose SkillComposer, which treats skill selection as a structured prediction problem—jointly deciding which skills to use, how many times, and in what order.

Yuanda Xu, Zhengze Zhou, Hejian Sang et al.

When training agents that interact with environments through discrete actions, assigning credit based on semantic role categories (not just final outcomes) reduces variance and improves learning by properly rewarding exploration and penalizing waste.

TRIAGE improves credit assignment in agentic RL by classifying action segments into semantic roles (progress, exploration, infrastructure, regression) and assigning role-specific rewards.

Kaisen Yang, Zheng Jiang, Yuzhao Peng et al.

Browser agents can scale more efficiently by learning from the implicit skills already present in human web interactions rather than from manually designed tasks, using skill distillation to convert trajectories into reusable, composable natural-language instructions.

This paper proposes a scalable approach for training browser agents by distilling human web browsing interactions into reusable natural-language skills. Rather than training agents from scratch on individual tasks, the method converts user interaction traces into compact skill descriptions that agents can retrieve and compose, organized in a skill graph to enable efficient learning and reuse.

Benjamin Breen, Austin Letson, Borja Requena Pozo et al.

Agentic code generation can be dramatically improved by using verification feedback to guide iterative repair of both code and formal proofs, rather than trying to generate correct code in one shot.

AxDafny is a system that helps AI models generate verified code in Dafny by iteratively fixing code and proofs based on verification feedback. The authors created a benchmark of 250 programming problems and show their approach achieves 92.7% verification success, significantly outperforming previous methods.

Xuan Zhang, Wenxuan Zhang, See-Kiong Ng et al.

World models can be continuously improved during deployment by learning from real interactions and filtering unreliable predictions, making LLM agents better at long-horizon planning without modifying the agent itself.

This paper presents WorldEvolver, a framework that improves LLM agent planning by maintaining and updating a world model at test time. The system uses three components—episodic memory (storing real transitions), semantic memory (learning rules from errors), and selective foresight (filtering unreliable predictions)—to provide better action consequence predictions without retraining the agent.

Yuhong Deng, Yuyao Liu, David Hsu

By decomposing tool affordance grounding into semantic (which object/part) and geometric (where) levels, robots can generalize to novel objects and creative tool use without expensive end-to-end training.

GROW² enables robots to creatively use any available object as a tool by breaking down the problem into two steps: using vision-language models to identify which object and which part to use, then using vision models to locate the exact 3D position. This lets robots solve tasks like cutting cake with a plate when no knife is available, without needing large labeled datasets.

Lei Bai, Zongsheng Cao, Yang Chen et al.

You can match trillion-parameter model performance on complex reasoning tasks with a 35B model by focusing on longer, more complex action sequences and multi-domain expertise rather than raw parameter count.

Agents-A1 is a 35B parameter model that achieves trillion-parameter performance on complex tasks by scaling agent horizon—the length and complexity of action sequences—rather than model size.

Kunyang Li, Kyle Domico, Jonathan Gregory et al.

In multi-agent systems, a small number of communication channels often control most of the attack surface—MESA can identify these critical edges proactively, letting defenders protect 3x more attacks with the same security budget.

This paper introduces MESA, a framework for identifying which communication channels in multi-agent systems are most critical to protect. By analyzing graph structure and testing channel importance without needing attack data, MESA ranks edges by their security risk, helping defenders focus limited resources on the most vulnerable connections before attacks happen.

Rajesh Jayaram, Drew Tyler, David Woodruff et al.

AI-assisted peer review can augment (not replace) human reviewers by catching errors early and reducing their workload, but requires careful design to preserve human oversight and decision-making authority.

Google researchers introduce Paper Assistant Tool (PAT), an AI system that automatically reviews scientific papers by checking mathematical proofs, validating experiments, and identifying flaws. PAT uses inference scaling to catch errors before human peer review, addressing the bottleneck created by AI-accelerated research outpacing traditional review capacity.

Bo Shen, Lifeng Chang, Tianyuan Wei et al.

Autonomous agents need internal, runtime defenses beyond training-time alignment—ANIS provides a biologically-inspired immune system that monitors and protects an agent's memory, tools, and multi-agent interactions from active exploitation.

This paper introduces Agent-Native Immune System (ANIS), a defense framework built directly into autonomous agents to protect against runtime attacks like memory poisoning and tool manipulation. Unlike traditional external security measures, ANIS operates within the agent's reasoning loop through a six-layer architecture and continuously learns to adapt to new threats.

Daniel Russo

Evaluating AI coding agents one at a time on isolated tasks misses the real problem: agent contributions create twice as much integration friction in shared codebases, making ecosystem-level governance more important than agent-level performance.

This paper studies how autonomous coding agents affect shared software repositories by analyzing over 930,000 pull requests. It finds that integration friction—the cost of merging code when others are changing it simultaneously—is largely a repository-level problem, not an agent problem.

Tianyi Men, Zhuoran Jin, Pengfei Cao et al.

Small 7B models can outperform much larger 32B models at web automation by learning high-level task decomposition through autonomous exploration and hindsight experience, rather than just memorizing low-level actions.

This paper improves small multimodal AI models for web automation by having them autonomously explore environments to learn task planning. The key innovation is using 'hindsight experience'—learning from failed attempts by reframing them as high-level tasks—which helps models generalize to new websites better than training on low-level atomic actions alone.

Josef Chen

Before building a multi-model system, measure how often all your models fail together—this sets a hard ceiling on possible gains. Standard error correlation metrics won't tell you this, but a simple statistical bound will.

This paper reveals a fundamental limit on multi-model LLM systems: their accuracy gains are capped by how often all models fail together on the same question. The authors measure this 'co-failure rate' across 67 frontier models and show that standard metrics like error correlation miss this ceiling, making it invisible to practitioners.

Wen Ye, Peiyan Li, Tingyu Yuan et al.

Test-time scaling for robots works better when you combine reasoning with action planning, track historical context, and use closed-loop feedback—enabling significant performance gains without retraining.

E-TTS is a framework that improves robot manipulation by combining reasoning and action planning at test time, using historical context and feedback loops. It works with existing vision-language-action models without retraining, achieving up to 33% performance gains in simulation and 27% in real-world tasks.

Junhao Shi, Zezheng Huai, Siyin Wang et al.

Persistent robot autonomy requires separating planning, memory, and verification into distinct components rather than relying on a single model; OmniAct demonstrates this approach scales to 100k+ interaction tokens while maintaining performance on real-world tasks.

OmniAct is a framework for building embodied robots that can perform long-horizon tasks in real-world environments by combining planning, memory management, and failure detection.

Zhengyuan Liu, Stella Xin Yin, Min-Yen Kan et al.

When building human-AI collaborative systems, pay attention to metacognitive dialogue (how teams reflect on and adjust their approach) alongside task progress—it's a key indicator of collaboration quality.

This paper presents a framework for analyzing dialogue during collaborative problem-solving between humans and AI systems.

Fabiana Fournier, Lior Limonad

You can add agentic AI capabilities to existing business processes by wrapping them with policy-governed agents at specific control points, rather than rebuilding the entire system.

This paper introduces a 'process harness'—a layer that adds AI reasoning to existing business workflows without replacing them. It uses three types of AI agents (for tasks, decisions, and flow control) that operate within policy guardrails, letting legacy systems maintain structural control while gaining adaptive intelligence at key decision points.

Babak Rahmani, Sebastian Dziadzio, Joschka Strüber et al.

You can reverse-engineer an agent's decision logic from its behavior by combining observation with strategic experimentation—a technique that works for policy interpretability and opponent modeling in competitive settings.

RevengeBench is a benchmark for reconstructing hidden decision-making code from an agent's behavior in games. Researchers observe a hidden policy playing and can design custom opponents to probe its behavior, then submit executable code that mimics it.

Aditya Singh, Gerson Kroiz, Senthooran Rajamanoharan et al.

Detecting bad behavior isn't enough to prove misalignment—you need forensic investigation to distinguish between malicious intent and innocent mistakes like confusion or shortcuts.

This paper develops a protocol for investigating whether concerning AI model behaviors stem from misalignment (intentional deception) or benign causes like confusion. The authors use chain-of-thought reasoning to generate hypotheses about behavior, then test these hypotheses through targeted prompt and environment modifications across six agentic scenarios.

Seth Dobrin, Łukasz Chmiel

AI safety controls embedded in an agent's own code can be bypassed; instead, safety enforcement should run in a separate process with formal verification, acting as an external referee that agents cannot manipulate.

This paper proposes the Unfireable Safety Kernel, a system that enforces AI safety constraints at the execution level—outside the AI agent's own code—rather than relying on internal safeguards.

Maggie Wang, Lars Osterberg, Stephen Tian et al.

By making VLA models steerable at the primitive-action level, you can create a self-improving loop where robots identify skill gaps, practice autonomously, and expand their capabilities continuously.

InSight enables vision-language-action models to autonomously learn new manipulation skills by breaking down demonstrations into reusable primitive actions (like "move gripper to bowl").

Negin Raoof, Richard Zhuang, Marianna Nezhurina et al.

Systematic data curation matters more than you might think—the right mix of task sources and diversity in training data significantly improves how well agents generalize across different benchmarks.

This paper presents OpenThoughts-Agent, an open framework for creating training data for AI agents that can handle diverse tasks. The authors ran 100+ experiments to understand what makes good training data, then created a 100K example dataset that improved agent performance by 3.9 percentage points over existing open models.

Tian Zheng, Kai-Tai Hsu

Evaluating agentic systems requires multi-layered grading strategies with different failure modes; a cascade combining strict pattern matching, lenient LLM grading, and human review is more reliable than any single approach.

This paper tackles the challenge of evaluating agentic data analysis systems that produce complex outputs like code, results, and explanations. The authors develop a three-layer grading cascade combining regex matching, LLM-based evaluation, and human review, achieving 97% recall while maintaining 100% precision. They show that iterative nudging improves grading success from 36% to 97%.

Ali Pourghasemi Fatideh, Wilder Baldwin, Maria Dhakal et al.

LLM dialogue systems for compliance assessment suffer from low accuracy against expert ground truth, and user satisfaction decreases with longer responses—designers should prioritize concise, proactive interactions over verbose explanations.

This paper evaluates how well LLM dialogue assistants (like GitHub Copilot) help developers assess non-functional requirements like HIPAA compliance. The researchers had 49 programmers use Copilot to evaluate 148 compliance requirements against real code, measuring both accuracy against expert standards and user satisfaction across multi-turn conversations.

Hovhannes Tamoyan, Sean Narenthiran, Erik Arakelyan et al.

By combining structured diagnostic reasoning with efficient repository exploration, SHERLOC helps coding agents spend less time searching for bugs and more time fixing them—improving fix success rates by ~6% while cutting token usage by a quarter.

SHERLOC is a framework that helps AI coding agents quickly find and diagnose bugs in large codebases. Instead of just pointing to buggy files, it provides the reasoning and context needed to actually fix them. The system uses reasoning-focused language models with repository tools and achieves state-of-the-art results while using 36% fewer tokens than competing approaches.

Sara Dorfman, Maya Vishnevsky, Omer Dahary et al.

By generating diverse prompts rather than diverse images from one prompt, you can create navigable design spaces where each variation is semantically meaningful and user-understandable, rather than random visual differences.

This paper solves the diversity problem in text-to-image generation by shifting variation from the model's random sampling to the text prompt itself.

Juyang Bai, Laixi Shi

Prompt optimization can significantly improve multi-agent systems, but gains vary dramatically depending on task complexity, team structure, and communication patterns—there's no one-size-fits-all approach.

This paper studies how to optimize system prompts for multi-agent LLM systems—where multiple AI agents work together with different roles and communication patterns. The researchers test prompt optimization techniques across different team sizes, workflows, and tasks to understand when and how much these optimizations actually improve performance.

Jincheng Zhong, Weizhi Wang, Che Jiang et al.

Enterprise agents need evaluation frameworks that measure artifact quality, cost, runtime, and skill transfer—not just task completion—because real workplace tasks are complex, heterogeneous, and require reproducible, auditable results.

This paper introduces EnterpriseClawBench, a benchmark for evaluating AI agents in real workplace environments. Built from actual enterprise sessions, it contains 852 reproducible tasks involving file handling, tool use, and business artifact creation.

Jun He, Deying Yu

For production AI agents controlling infrastructure, enforce mutations through a separate broker that validates certificates at execution time, not just at decision time—this creates a mandatory checkpoint that agents cannot bypass.

This paper introduces Sovereign Execution Broker (SEB), a runtime enforcement system that sits between AI agents and infrastructure APIs to ensure mutations (changes) only happen when authorized by valid certificates.

Asa Shepard, Jeannie Albrecht

Automatically tuning repository guidance through synthetic bug probes improves coding agent performance by 7.5 percentage points, primarily by helping agents locate correct files rather than improving code quality.

This paper shows that repository guidance files (like AGENTS.md) help coding agents fix bugs, but only if created the right way. The authors introduce probe-and-refine tuning: a method that tests guidance against synthetic bugs and automatically improves it.

Alaia Solko-Breslin, Pramod Kaushik Mudrakarta, Mihai Christodorescu et al.

You can now formally verify AI agent security policies with probabilistic components (like imperfect detectors) and get mathematical guarantees on violation rates, even when you don't know how errors correlate.

This paper presents a framework for verifying that AI agents follow security policies even when using unreliable components like PII detectors or classifiers that sometimes fail. Unlike existing approaches that assume perfect detection, this method computes guaranteed upper bounds on policy violations using robust optimization, without requiring assumptions about how errors correlate.

Zewen Liu

Evaluator bias in LLM-based multi-agent systems spreads between agents like contagion, but using multiple evaluators (k=3 vs k=1) cuts this propagation by 72%—a simple mitigation for production systems.

This paper studies how evaluation biases spread through multi-agent LLM systems. Using a mathematical framework called Contagion Networks, researchers measured how one agent's evaluator bias influences other agents' behavior in a 3-agent system.

Shu Yao, Yuhua Luo, Qian Long et al.

Multi-device agents need hierarchical recovery strategies that distinguish between local device failures (fixable with alternative approaches) and global failures (requiring task replanning), rather than treating all failures the same way.

This paper presents H-RePlan, a framework that helps AI agents recover from failures when working across multiple devices (like computers and phones). Instead of replanning entire tasks when something goes wrong, the system first tries to fix problems locally on each device, only escalating to global replanning when necessary.

Jake J. Xia

Collective intelligence isn't about maximizing order—it's about finding the right balance between coordination and flexibility based on what the system needs to achieve.

This paper develops a framework for understanding multi-agent systems by analyzing how individual agent properties (power and response functions) create emergent collective behaviors. It shows that synchronization increases output but can reduce resilience, and derives an optimal balance between order and adaptability based on system objectives.

Mingyu Yang, Keye Zheng, Congchao Cheng et al.

MAA enables agents to learn which memory operations consistently help by accumulating cross-batch evidence, making agent self-improvement more efficient and reliable without requiring online training.

This paper addresses a problem in training AI agents: when the same memory operation gets conflicting feedback across different training batches, it's hard to know which operations actually work. MAA solves this by accumulating evidence for each operation across batches and filtering out unreliable ones, improving agent learning while using 75% fewer tokens during training.

Inesh Chakrabarti, David Limpus, Aditi Ghai Rana et al.

4-bit KV cache compression can dramatically speed up multi-turn agent interactions by reducing memory pressure, but requires careful design choices like asymmetric K/V treatment and hardware-specific optimizations to work reliably in production.

This paper optimizes key-value cache memory for AI agents that maintain long conversation histories by compressing KV data to 4-bit precision. The authors develop practical techniques including asymmetric compression, specialized rotations, and GPU-optimized kernels that achieve 3.47x faster response times in later conversation turns while maintaining output quality.

Reza Soosahabi, Vivek Namsani

Misdirection-based defenses that provide false feedback to automated attackers are more effective than simple refusals, which attackers can easily detect and learn from during automated search.

This paper analyzes how AI systems can defend against automated jailbreak attacks by using misdirection instead of simple refusals. Rather than blocking attacks predictably, the system gives misleading but safe responses that confuse the attacker's automated evaluation tools, making it harder for attackers to know if their prompts actually worked.

Hanwool Lee, Dasol Choi, Bokyeong Kim et al.

LLM agents in safety-critical systems have overlapping but distinct failure modes under adversarial pressure, meaning you can't rely on a single defense strategy across different models.

NRT-Bench is a benchmark that tests how well LLM agents can safely operate a simulated nuclear power plant when facing sustained, adaptive attacks over multiple turns. The benchmark reveals that current frontier models fail 8.7-12.1% of the time under attack, and crucially, each model has different vulnerabilities—defenses that help one model can actually hurt another.

Zhenghao Xing, Ruiyang Xu, Yuxuan Wang et al.

Active perception—where an AI agent decides what to observe rather than passively processing everything—enables better video understanding with lower computational cost and improves with more reasoning steps.

OmniAgent is an AI agent that watches videos intelligently by deciding what to pay attention to, rather than processing every frame. It combines audio, visual, and text understanding in a reasoning loop, building up memory of important moments. This approach scales better with video length and achieves top performance on video understanding benchmarks.

Yingshan Susan Wang, Cedegao E. Zhang, Linlu Qiu et al.

Training user simulators to be indistinguishable from real users (via Turing-test-style rewards) works better than training them to match specific ground-truth responses, enabling more realistic evaluation of conversational AI systems.

This paper proposes Turing-RL, a new method for training AI models to simulate human users in conversations. Instead of teaching models to match specific human responses word-for-word, it uses a judge (another LLM) to score how realistic and indistinguishable the simulated responses are from real human behavior.

Anoushka Vyas, Aarushi Dhanuka, Sina Khoshfetrat Pakazad et al.

Autonomous coding agents that execute and validate their own code outputs, combined with shared memory for experience reuse, outperform text-only approaches for data integration tasks and generalize across different SQL dialects and query types.

Data Intelligence Agents (DIA) is a production system using three autonomous coding agents to automate enterprise data workflows—interpreting raw data, creating schemas, and generating SQL queries.

Leyang Shen, Yang Zhang, Xiaoyan Zhao et al.

When building LLM systems for real-world decisions involving multiple stakeholders with conflicting interests, use iterative game-theoretic reasoning rather than one-shot reasoning—agents improve by learning from and countering each other's strategies.

This paper introduces Multi-Agent Fictitious Play (MAFP), a framework where LLM-based agents represent different stakeholders and iteratively improve decisions by responding to each other's past choices.

Nikita Kachaev, Andrey Moskalenko, Matvey Skripkin et al.

VLA models trained for robotics lose significant commonsense and world knowledge compared to their base vision-language models, particularly on complex semantic tasks—a critical finding for building reliable embodied AI systems.

This paper introduces Act2Answer, a benchmark that measures whether vision-language-action (VLA) models—AI systems trained to understand images and perform robot actions—retain commonsense and factual knowledge after fine-tuning on robotics data.

Shanda Li, Qiuhong Anna Wei, Jingwu Tang et al.

LLM agents can effectively identify reproducibility issues in ML papers by analyzing code repositories, even without execution—but they struggle with precise localization of problems.

ReproRepo is a scalable framework that uses GitHub issues as natural training data to evaluate whether AI agents can identify reproducibility problems in machine learning research. Testing on 1,149 papers, the best agent found at least one relevant issue for ~90% of papers, showing LLMs can spot real-world blockers without running code.

Qi Chai, Wenhao Shen, Nanjie Yao et al.

By learning from past navigation failures and predicting outcomes before acting, zero-shot object navigation can improve significantly without retraining—achieving 10% better success rates with fewer wasted steps.

This paper presents EvolveNav, a framework for embodied agents to find objects in unseen environments without prior training. It builds a memory of successful navigation rules from past attempts and uses them to guide future exploration, reducing trial-and-error through predictive planning before taking actions.

Ankita Samaddar, Sandeep Neema, Daniel Balasubramanian et al.

Autonomous cyber-defense systems can predict attacker actions without directly observing them by learning from network data and defender responses, enabling smarter, adaptive security.

This paper develops a technique for autonomous cyber-defense agents to learn and predict attacker behavior in partially observable networks. Using imitation learning, the system learns what an attacker might do based on network observations, helping defenders anticipate threats and adapt their security strategies in real-time.

Tongyan Fang, Siyuan Huang, Naiyu Fang et al.

Splitting sparse episode outcomes into separate success and efficiency signals with state-adaptive weighting, plus intervention-aware credit assignment, enables effective online RL fine-tuning of robot policies from minimal supervision.

This paper solves a key problem in robot learning: when fine-tuning pretrained vision-language-action models through trial-and-error, each episode only gives a binary success/failure signal, but the model needs per-step feedback.

Anzhe Xie, Weihang Su, Yujia Zhou et al.

LLM agents excel at finding papers but fail at the harder task of determining whether papers actually meet study eligibility criteria—a bottleneck that stage-specific metrics can help diagnose better than single overall scores.

MetaSyn is a benchmark dataset of 442 expert-curated meta-analyses from Nature journals that tests how well AI systems can perform evidence synthesis—retrieving relevant studies, screening them against eligibility criteria, and aggregating results.

Buqiang Xu, Zirui Xue, Dianmou Chen et al.

Effective context pruning for agents requires preserving prompt cache structure—TokenPilot achieves 56-87% cost reduction by removing content conservatively rather than aggressively rewriting prompts.

TokenPilot manages context in long-running AI agents by smartly removing unnecessary information while keeping the prompt cache valid. It uses two strategies: cleaning up noise when information enters the system, and removing old context only when it's no longer useful. This cuts inference costs by 56-87% while maintaining performance.

Jundong Xu, Qingchuan Li, Jiaying Wu et al.

LLM agents need to track how their environment evolves over time to work reliably in the real world—EvoMem shows that explicitly recording memory changes improves agent performance on both dynamic and standard benchmarks.

EvoArena is a benchmark that tests LLM agents in dynamic environments where conditions change over time, and EvoMem is a memory system that tracks how environments evolve. Current agents struggle with these changing conditions (39.6% accuracy), but EvoMem improves performance by recording structured update histories, helping agents understand what has changed.

Seokju Cho, Ryo Hachiuma, Abhishek Badki et al.

Using executable code as an action interface lets vision-language models flexibly compose spatial reasoning operations and adapt to intermediate results, significantly improving performance on 3D/4D reasoning tasks without model-specific tuning.

SpatialClaw is a framework that helps AI agents reason about 3D space and object relationships by letting them write and execute Python code step-by-step. Instead of committing to a full analysis upfront or using rigid tool menus, the agent can see intermediate results and adapt its approach, achieving 59.9% accuracy across spatial reasoning tasks—11.2 points better than prior methods.

Zongsheng Cao, Bihao Zhan, Jinxin Shi et al.

Instead of feeding agents flat paper summaries, this work structures scientific knowledge into queryable graphs with explicit entities, claims, and evidence—making it easier for AI systems to perform multi-step scientific reasoning and fact-checking.

Agents-K1 builds agent-friendly knowledge graphs from scientific papers by extracting entities, claims, evidence, and relationships across full documents—not just abstracts. The system combines a multimodal parser, an information-extraction model trained with reinforcement learning, and a unified interface for searching and traversing knowledge.

Yaxin Du, Yifan Zhou, Yujie Ge et al.

Bundling multiple tool calls into executable code blocks dramatically improves agent performance on multi-step tasks—doubling accuracy on some benchmarks by reducing the overhead of step-by-step tool management.

HyperTool lets AI agents call multiple tools in a single code block instead of one at a time, reducing context waste and improving performance. Rather than exposing each tool call separately, agents write code that chains tools together locally, making complex workflows more efficient.

Amy Xin, Jiening Siow, Junjie Wang et al.

The key bottleneck for autonomous scientific discovery isn't better agent algorithms—it's better environment design. By engineering constraints, collaboration tools, and oversight mechanisms, you can make agents more reliable and productive at discovering new solutions.

EurekAgent is an AI agent system designed to automate scientific discovery by focusing on environment engineering—the resources, constraints, and interfaces that shape agent behavior.

Elias Lumer, Sahil Sen, Kevin Paul et al.

Spawning parallel subagents with independent tools and planning is more effective for complex long-context tasks than having a single agent handle everything—this architectural pattern improves coding performance from 71.75% to 81.36% on long documents.

This paper introduces Recursive Agent Harness (RAH), a pattern where AI agents spawn subagents to handle complex tasks in parallel rather than processing everything in a single call. Like how recursive language models break down reasoning into multiple model calls, RAH breaks down work into multiple agent instances, each with their own tools and planning capabilities.

Achraf Hsain, Sultan Almuhammadi

Shield synthesis is most valuable for analyzing whether a system architecture can be defended at design time, not for enforcing safety during deployment—formal defensibility and operational robustness are distinct properties that require different metrics.

This paper reframes shield synthesis—a technique that uses formal logic to restrict agent actions—as a design-time analysis tool rather than a runtime safety mechanism.

Xiaoyuan Liu, Jianhong Tu, Yuqi Chen et al.

Agent evaluation should use standardized protocols and agent-based judges instead of fixed benchmarks—this makes comparing different agent designs fair and reproducible at scale.

AgentBeats proposes a new way to evaluate AI agents using other agents as judges, rather than fixed benchmarks. Instead of building separate evaluation systems for each agent type, all agents communicate through standardized protocols (A2A and MCP), making evaluation fairer, more reproducible, and compatible with real-world constraints like privacy and openness.