Papers

Yizhe Chi, Wenyi Li, Deyao Hong et al.

Current LLM agents struggle to design better training algorithms: even the best system closes only 20% of the gap between existing algorithms and optimal ones, suggesting recursive self-improvement through algorithmic design remains far out of reach.

This paper introduces AI4AI-Bench, a benchmark that tests whether AI agents can improve training algorithms themselves—a key capability for recursive self-improvement. The benchmark uses 10 frozen code repositories where agents get 4 hours to rewrite training algorithms, then the code runs for 12 hours and is scored against the original.

Adam Fisch, Shubhendu Trivedi, Fantine Huot et al.

Use value-of-information theory to decide when to invest in expensive model quality estimates before routing—this cuts estimation costs dramatically while maintaining routing accuracy.

This paper solves the problem of efficiently routing queries to the best AI model in a system with multiple specialists. The key challenge: estimating which model will perform best costs money (slow but accurate estimators vs. fast but noisy ones).

Fengqing Jiang, Yite Wang, Boyi Liu et al.

Tool-use capabilities in language models improve significantly when trained during mid-training with targeted synthetic data, rather than waiting until post-training—similar to how math and reasoning skills benefit from dedicated training phases.

MidTool is a data synthesis pipeline that creates training data for teaching language models to use tools effectively during mid-training (the stage between pretraining and fine-tuning).

Yiyang Feng, Biddut Sarker Bijoy, Niranjan Balasubramanian et al.

Subtask-level skills expressed as text transfer more reliably across tasks than task-level or code-based skills, and you can predict skill usefulness by balancing how specific it is versus how broadly applicable it is.

This paper studies how LLM agents can learn and reuse skills from completed tasks. The researchers compare different ways of capturing skills—at the task level versus subtask level, and as text versus code—and find that breaking skills into subtasks and expressing them as text leads to better transfer across new tasks.

Sahil Sharma

After AGI, human employment becomes irrelevant to economic growth, but human welfare depends entirely on ownership policy: without legal protections, the machine economy will grow exponentially while human wealth share decays to zero.

This paper models a post-AGI economy where AI and robots are both producers and consumers, creating a self-sustaining corporate system independent of human demand. It shows that without human ownership stakes, GDP growth becomes decoupled from human welfare—machines reinvest all output for exponential growth while humans face wealth erosion unless laws protect their ownership share.

Mengru Wang, Haozhe Luo, Zhenqian Xu et al.

Memory in LLMs can hurt performance even when perfectly accurate and relevant—the problem isn't retrieval quality but how retrieved information biases reasoning. A simple prompt-based fix can recover performance without redesigning memory systems.

This paper identifies and benchmarks 'cognitive traps' where LLMs with memory systems retrieve accurate, relevant information that paradoxically harms reasoning on current tasks. The authors introduce MemTrapBench to evaluate two failure modes (reasoning fixation and belief distortion) and propose AdaptiveMem, an inference-time method to mitigate these traps while maintaining memory benefits.

Wei Lin, Tao Zhou, Zhaofei Xie et al.

Future software will be built from three components—storage, models, and agents—replacing traditional layered architecture. This shift means developers must rethink how they structure applications, with AI models handling logic and interfaces rather than hand-coded layers.

This paper argues that software architecture is undergoing a third major shift—from instruction-based (Software 1.0) and data-driven (Software 2.0) systems to context-and-reasoning-driven systems (Software 3.0).

Zhijun Gao, Jing Chen

AI coding agents use documentation very differently than humans: they rely heavily on agent-facing artifacts, rarely validate code against docs, and treat documentation as a secondary reference rather than a guide for implementation.

This study analyzes how AI coding agents interact with documentation by examining 557 coding sessions and 33,097 pull requests.

Atsuyuki Miyai, Kiyoharu Aizawa, Toshihiko Yamasaki

You can optimize LLM agent behavior (harness code) much faster by only evaluating tasks where the agent struggles or disagrees with itself, rather than testing everything every iteration.

This paper introduces Task-CoEvolve, a method that makes LLM agent harness optimization faster by intelligently selecting which validation tasks to evaluate at each iteration. Instead of evaluating all tasks every time, it focuses on tasks where the agent's performance is uncertain, reducing evaluation costs by 80% while maintaining the same final performance.

Mehdi Azarafza, Faezeh Pasandideh, Ali Ehteshami Bejnordi et al.

LLMs work best in autonomous systems when used for reasoning and planning rather than direct control—this hybrid approach maintains safety while gaining contextual understanding for complex driving decisions.

This paper proposes a hybrid autonomous driving system that combines reinforcement learning, PID control, and LLM reasoning through an orchestrator.

Poomphob Suwannapichat, Boonyarit Changaival, Caesar Wu et al.

You can train LLM-based multi-agent systems to communicate more efficiently by using a reward model that balances task correctness with sparse communication patterns—no accuracy loss needed.

This paper improves multi-agent LLM systems by automatically designing communication topologies (how agents talk to each other) that use fewer tokens while maintaining accuracy. It uses a reward model to guide graph generation, reducing token consumption by 20.5% compared to prior work.

Bo Liu, Simon Yu, Yiding Jiang et al.

Making environment design itself learnable—rather than hand-curated or static—enables continuous self-improvement in language agents by automatically generating appropriately-difficult, diverse training tasks.

SPADE is a self-play framework where a single language model learns two roles: designing custom training environments as executable code, and solving problems within them. The environment designer learns to create challenges at the edge of the agent's abilities, automatically adapting as the agent improves.

Ramneet Kaur, Pradyumna Chari, Ramesh Raskar et al.

AI agents communicating through hidden internal states can coordinate deception undetectably—but you can monitor and prevent this by tracking latent activations and using counterfactual analysis to steer behavior back to compliance.

This paper addresses a critical safety problem: AI agents can coordinate harmful behavior through hidden communication channels in their internal states, invisible to human oversight.

Bingxin Xu, Yuzhang Shang, Emilio Ferrara

Breaking long robot tasks into independently explored subtasks with explicit transition management reduces exploration cost from exponential to linear and improves success rates by 15% on benchmarks.

This paper presents BATON, a system for long-horizon robot manipulation that combines vision-language-action models with LLM planning. Instead of learning end-to-end, BATON explores individual subtasks cheaply, stores solutions in memory, and chains them together while managing transitions between subtasks using a verifier agent and handoff mechanisms.

Kejia Zhang, Youran Sun, Xinyu Ren et al.

Symbolic regression works better when you preserve the scientific reasoning behind each equation candidate—not just the formula itself—allowing AI agents to learn from failed attempts and build credible explanations for why one equation is better than others.

AutoSR is an automated system that discovers scientific equations from data by treating symbolic regression as a research investigation rather than just equation fitting.

Ajith Anil Meera, Pablo Lanillos, Wouter Kouw

Expected Free Energy provides a single, tunable objective that lets robots efficiently explore unknown environments by balancing information gathering with resource constraints—useful for real-world autonomous missions.

This paper applies Expected Free Energy from active inference to robotic path planning for Mars exploration. The robot must balance two goals: building accurate maps and finding high-value regions (like water sources) while staying within travel and measurement budgets. The approach outperforms traditional information-seeking methods by unifying both objectives under one principled framework.

Yaxin Luo, Haobin Jiang, Jialv Zou et al.

You can automatically optimize how agents interact with tools by having them learn from rollout feedback—AutoDesign shows this approach consistently improves performance across different models and scales to real-world tasks.

AutoDesign is a framework that automatically improves how AI agents interact with tools by learning from feedback. It treats complex tasks like converting academic papers into posters as a long-horizon process where a meta-optimizer guides a code agent to refine its interaction patterns.

Bobo Li, Hao Fei, Tianjie Ju et al.

Direct perception of raw scientific data—not just text summaries—is critical for AI systems to conduct rigorous, evidence-grounded research. OmniScientist shows that multimodal input improves all aspects of automated scientific discovery.

OmniScientist is an AI system that conducts scientific research across multiple disciplines by directly processing raw data in many formats—images, videos, audio, 3D structures, tables, and more.

Shangao Li, Yao Zhang, Volker Tresp et al.

Don't trust matched evaluation scores for coding agents—they hide failures introduced by command serialization and parsing.

This paper reveals that standard evaluation metrics for LLM coding agents can hide critical failures in command execution. By testing how Bash commands survive serialization and parsing in different system configurations, the authors show that matched scores mask up to 73% of actual failures—failures introduced not by the model but by how its output is processed.

Lei Bai, Jiaqi Cao, Chiyu Chen et al.

This work demonstrates how to build AI agents for science by combining multimodal pre-training with agentic reinforcement learning and memory-augmented architectures, achieving strong performance on scientific reasoning and forecasting tasks without requiring task-specific model modifications.

Intern-S2-Preview is a large multimodal AI system designed to tackle scientific discovery tasks by reasoning over diverse data types, using scientific tools, and working across long-horizon problems.

Saisha Shetty, Satvik Tripathi, Austin Lin et al.

For clinical AI, breaking monolithic prompts into traceable multi-agent workflows improves interpretability and failure diagnosis compared to single-LLM approaches, while remaining accessible to non-programmers.

MARC is an open-source framework that replaces single-prompt LLM calls with coordinated teams of specialized agents for clinical reasoning. Each agent handles a specific task (extracting data, reasoning, generating answers, evaluating results), with clear handoffs between stages so failures can be traced.

Mohammed Ayman Habib, Rylan Hart, Morteza Fayazi

LLMs can automate the full analog circuit design process—not just sizing or topology separately—by using multiple agents that debate and refine designs, achieving 40x faster results than manual approaches while discovering novel circuit topologies.

AaLLM is an end-to-end framework that uses multiple AI agents working together to automatically design analog circuits from scratch. It takes design requirements as input and outputs complete circuit designs (both the circuit structure and component values), reducing the time-consuming manual work that circuit engineers typically do.

Aimilios Hadjiliasi, Louis Nisiotis

Small language models can efficiently run agent cognition (thinking and memory) on edge devices like Jetson boards, enabling virtual agents to operate independently in real-time without cloud latency.

This paper explores how small language models (SLMs) running on edge devices can power the cognitive processes of virtual agents in immersive worlds.

Yiwei Li, Wanli Yang, Hexiang Tan et al.

Current AI agents excel at combining existing techniques but lack the consistency and genuine innovation needed for autonomous research; improving their performance requires better experience management and more stable inference strategies, not just larger models.

This paper evaluates how well AI agents can autonomously improve technical systems through long-horizon experimentation. Rather than just looking at final scores, the researchers developed a framework to analyze what happens during the process—how agents formulate solutions, execute them, and learn from feedback.

Shivam Vats, Sudarshan Harithas, Mete Tuluhan Akbulut et al.

When robots have limited time to practice, you can use optimization to compute exactly which skills to learn and how long to spend on each—trading off learning difficulty against the reward value each skill unlocks.

This paper tackles how robots can learn skills efficiently when practice time is limited. The authors propose Deliberate Practice, an algorithm that decides which skills to practice and for how long to maximize task performance within a fixed budget. They use a mathematical optimization approach to find the best allocation of practice time across different skills.

Muhammad Hannan Akram, Muhammad Abubakar Rashid, Wassi Haider Kabir et al.

Heterogeneous AI agents can efficiently synchronize their understanding in distributed networks by translating belief updates through edge-deployed models, without requiring shared training or identical architectures.

This paper proposes a framework for AI agents in 6G networks to synchronize their understanding (beliefs) despite using different AI models and operating under different constraints.

Chuyue Li, Jinpeng Yu, Haozhe Wang et al.

Agents can now learn from and generate high-quality videos by working with structured knowledge graph representations instead of raw pixels, improving video generation quality by 20.7% over existing methods.

AVA-Encoder learns video representations as knowledge graphs that agents can reason about and edit. It converts videos into structured text and asset layers, then reconstructs videos from these representations. A natural-language feedback loop optimizes the encoding, enabling agents to work with cinematic-quality videos more effectively.

Yan Deng, Fei Xu

For embodied AI agents navigating from visual instructions, explicitly modeling temporal context (past-only memory), multi-step planning with single-step execution, and decoupled termination detection significantly improves navigation success and efficiency.

DreamFly improves aerial drone navigation by combining three key techniques: a causal memory system that uses only past observations to avoid information leakage, a receding-horizon planning approach that predicts multiple future actions but executes one at a time, and explicit stop detection from action predictions.

Aman Tyagi, Hemanth Boinpally, Jonathan Chen et al.

Instead of manually tweaking prompts and settings repeatedly, you can use an AI agent to systematically optimize video generation—first refining what you ask for, then finding the best random parameters—making video synthesis more predictable and reliable.

This paper presents an agentic framework that optimizes image-to-video generation by automatically refining prompts and hyperparameters rather than relying on trial-and-error. It uses a multimodal language model to improve prompts based on semantic checks, then applies Bayesian optimization to find the best random seeds and settings, achieving 69% preference over baseline methods.

Ankita Rajaram Naik, Anupama Murthi, Benjamin Elder et al.

Current LLMs fail at the reasoning layer when using APIs in realistic settings: they struggle to connect information across sources and understand policy constraints, not because they can't call tools, but because they can't figure out what to call and in what order.

VAKRA is a benchmark with 8,000+ real APIs across 62 domains that tests whether AI agents can reason across multiple data sources and follow tool-use policies. Unlike existing benchmarks that test API calling or retrieval separately, VAKRA combines both in realistic enterprise scenarios.

Junliang Liu, Ruoyu Li, Wenxin Tang et al.

LLM agents can be hijacked to waste computational resources through carefully crafted skills that appear legitimate but steer agents toward costly execution paths—a threat that bypasses traditional task-completion checks.

This paper reveals a new attack on LLM agents that manipulates how they choose and use third-party skills. By crafting deceptive skill descriptions and instructions, attackers can trick agents into taking unnecessarily expensive detours—using more tokens and time—while still completing tasks correctly.

Alan Li, Rahul Saha, Anton Xue et al.

AI systems can make genuine research contributions in mathematics by discovering non-obvious insights, but their effectiveness depends heavily on how they're integrated into human workflows and problem formulation.

Researchers used an AI system to improve mathematical bounds on the Grothendieck constant, a fundamental problem in computational complexity. The AI discovered novel insights that human experts recognized as significant, demonstrating how AI agents can contribute meaningfully to pure mathematics research when given the right conditions.

Shiyu Xuan, Zechao Li

GUI agents can now self-improve after deployment by learning from their own failures through AI-guided reflection and self-distillation, achieving 7.4% accuracy gains without requiring human annotations.

This paper introduces a test-time adaptation framework for GUI visual grounding that allows models to improve after deployment without human feedback. The system uses a closed-loop process: agents explore interfaces, an AI reflector evaluates results and explains failures, and a self-distillation method internalizes these insights back into the model weights.

Zetao Hong, Song Yuan, Yuanhao Ding et al.

When running multiple RL training pipelines on shared inference hardware, intelligent scheduling of which requests to accept and how to allocate GPU memory between them can dramatically improve efficiency without compromising training quality.

This paper addresses a scheduling problem in LLM inference services that run multiple types of reinforcement learning workloads simultaneously. Different RL approaches (RLVR, RLHF, agentic) have different memory and timing needs, causing them to compete inefficiently for GPU cache.

Derin Gezgin, Jim O'Connor, Tanner Goodwin et al.

Dark Souls bosses are an extremely challenging RL benchmark—current deep RL methods achieve near-zero performance, suggesting the domain requires advances in long-horizon reasoning, sparse rewards, and real-time decision-making under pressure.

DSLE is a benchmark platform that turns Dark Souls boss fights into reinforcement learning environments. It provides 22 real-time combat scenarios with visual input and sparse rewards, plus a curated 5-boss subset for standardized evaluation. Current RL methods (PPO, DQN) fail dramatically, while even hand-crafted solutions barely beat the tutorial boss.

Wanying Qu, Qinghua Mao, Yu Li et al.

Instead of treating agent safety controls as static, you can automatically improve them by analyzing what goes wrong in practice and evolving specific components like rules and tool permissions—achieving 3x better safety without sacrificing utility.

This paper introduces SHE, a framework that automatically improves LLM agent safety by evolving the agent's control system (harness) rather than just the model weights. It breaks the harness into four modular components—system prompt, rules, memory, and tool access—and learns safer versions of each from failure examples, while maintaining the agent's usefulness.

Abraham Gonzalez, Raghav Gupta, Akanksha Jain et al.

Agentic AI can discover better microarchitecture designs than humans by breaking large search spaces into manageable pieces and embedding hardware constraints directly into the optimization loop.

ArchAgent v2 automatically designs data prefetching policies for computer processors using evolutionary search, beating hand-designed solutions in a competition. It introduces cascaded evolution (optimizing cache levels sequentially) and hardware-realizability feedback to handle the massive design space, achieving 3.8% performance improvement over baseline.

Mingxuan Zheng, Yujin Zhou, Chuxue Cao et al.

Agents can evolve skills more effectively by coupling failure diagnosis with proximal optimization: diagnose what went wrong, test fixes on the same tasks, then systematically audit and remove unhelpful skill components.

SkillProx improves how AI agents learn and refine reusable task skills by combining diagnostic feedback loops with a mathematical optimization approach. Instead of treating skill edits generically, it explicitly diagnoses failures, rolls back unsuccessful changes, breaks skills into auditable components, and removes or demotes unhelpful knowledge—improving task accuracy by 3 percentage points.

MY Pitsane, Hope Mogale

For developers building with coding agents: smart context eviction can cut token costs by a quarter while maintaining byte-exact reversibility, making long-running agentic coding tasks more affordable.

Blast Radius is a memory management system for AI coding agents that predicts how much context a prompt needs and intelligently removes unused code/context to save tokens. It archives dead code reversibly and identifies repeated patterns, reducing token use by 17-26% while keeping everything recoverable.

Mohammad Amanlou, Parham Abed Azad, Farbod Davoodi et al.

Emotional significance and unresolved conflicts should shape what memories an AI agent retrieves, not just semantic similarity—this improves handling of complex, emotionally-laden scenarios.

PsychoAgent is a memory system for AI agents that mimics how humans remember—not just by topic relevance, but by emotional importance and unresolved conflicts. It separates factual and emotional memories, then uses an emotional filter to surface conflict-critical information when needed, showing better retrieval of conflict-relevant memories than standard similarity-based approaches.

Jiacheng Miao, Jin Mu, Guanhua Chen et al.

LLM agents need specialized training on verified statistical tasks to reliably conduct hypothesis testing—standard benchmarks miss inferential errors, and reinforcement learning with statistical rewards substantially improves correctness.

LLM agents often make subtle statistical errors when conducting hypothesis testing, even when code runs correctly. This paper introduces P-Bench, a benchmark of 425 realistic hypothesis-testing tasks, and Fisher-R1, an open-weight agent trained with reinforcement learning to perform rigorous statistical analysis.

Ishan Patel, Sahil Sen, Elias Lumer et al.

Programmatic tool calling—letting models write code to invoke tools—is a simpler, more flexible alternative to JSON-based tool calling that performs as well or better across model generations, particularly for complex multi-tool scenarios.

This paper compares two ways for language models to use tools: programmatic tool calling (where models write Python code to invoke tools) versus native JSON tool calling (rigid structured calls).

Soorya Ram Shimgekar, Michelle Hu, Dorisa Shehi et al.

Automated feature engineering for clinical data is feasible when grounded in clinical guidelines and evidence trails, but requires careful validation and auditing to ensure reliability in real-world healthcare settings.

Researchers built an automated system (nMAS) to extract and engineer features from fragmented heart-failure patient records in electronic health records. The system combines multi-agent AI with clinical guidelines to generate interpretable features, reducing manual work that typically consumes 39-45% of data scientists' time.

Boning Li, Yu Chen, Longbo Huang

You can stop evaluating agents the moment you have statistical proof one is better, rather than running predetermined game counts—this cuts evaluation costs dramatically while keeping your confidence level mathematically sound.

This paper makes agent evaluation cheaper and faster by combining variance reduction (AIVAT) with statistically valid early stopping (Confidence Sequences). Instead of running a fixed number of games, the method stops as soon as there's enough evidence to declare one agent stronger, reducing evaluation costs by up to 74x while maintaining statistical guarantees.

Praphul Chandra, Sujit Gujar, Ganesh Ghalme

AI governance can be made self-enforcing by controlling compute resources through a mechanism-design framework where stakeholder votes directly determine an agent's computational budget via cryptographically signed licenses.

This paper proposes a formal mechanism for governing deployed AI agents through resource allocation. The system uses a participatory voting process where human stakeholders contribute to provision or rejection markets using a special governance currency.

Fanzhe Meng, Guoxin Chen, Jiale Zhao et al.

Training agents on tasks calibrated to be appropriately difficult (not too easy, not impossible) using multiple solver feedback produces better generalization than manually authored or single-solver validated tasks.

CalibForge automatically creates training tasks for AI agents by using multiple solvers to identify tasks that are challenging but solvable—the 'learnable zone.' It revises candidate tasks based on solver disagreement and performance patterns, then trains agents on these calibrated tasks, achieving significant improvements on code and repository understanding benchmarks.

Yunjia Qi, Zehua Yin, Xintong Shi et al.

When LLM agents fail at complex tasks, you need to trace which error actually caused the failure—not just find any mistake—because long trajectories have multiple errors with different downstream impacts.

TrajDebug is a framework for identifying critical errors in long agent trajectories by tracing error lifecycles and determining which mistakes actually caused final failures. It uses history compression and evidence-based analysis to handle scattered context, then tracks whether errors were resolved or led to terminal failure.

Noam Koren, Roy Bar-Haim, Abigail Goldsteen

You can use LLMs to automatically audit whether your conversational agent benchmarks are actually measuring what they should—catching issues like inconsistent tasks or oversimplified scenarios that would otherwise lead to misleading evaluation results.

This paper introduces a framework to evaluate the quality of benchmarks used to test conversational agents. Instead of assuming benchmarks are good, the authors use LLM judges to automatically assess whether benchmarks have consistent tasks, appropriate complexity, and good coverage of different agent behaviors.

Tao Wang, Qihao Yang, Rongjiao Liang et al.

LLMs struggle with rule-intensive document review tasks that require checking consistency across long, structured documents—a critical gap for professional applications like standards compliance where accuracy is non-negotiable.

This paper introduces GB/T-Bench, a benchmark for evaluating how well large language models can review national standard documents (like China's GB/T standards) for quality issues.

Sagar Tamang, Ayush Vyas, Tabarakul Hazarika

For structured documents with tables and inherited metadata, agentic search using deterministic operations outperforms embedding-based retrieval by 43 percentage points—the gain comes from the interface design, not from iteration or agent reasoning.

This paper challenges the standard retrieval approach for document-heavy domains like financial reports. Instead of embedding chunks and finding top-k matches, the authors propose READ: an agent that searches documents through deterministic operations (lexical search, structural navigation, span reads) exposed as tools.

Varun Ursekar, Apaar Shanker, Yash Maurya et al.

LLM capability depends heavily on the surrounding harness (prompts, tools, orchestration), and frontier models show measurable but inconsistent ability to optimize these components—a skill that will become increasingly important as AI systems become more agentic.

This paper introduces HarnessOpt-Bench, a benchmark for measuring how well large language models can automatically improve AI agent systems by editing their prompts, tools, and control flow.

Christo Kurisummoottil Thomas, Omar Hashash, Walid Saad

Networks can become active intelligence coordinators for physical AI by deploying reasoning agents (digital twins) that share spatiotemporal context through causal reasoning and transmit only beliefs with cognitive value, rather than optimizing for throughput alone.

This paper proposes holonic digital twins (HDT-Nets)—intelligent network agents that actively reason about their environment rather than passively mirroring physical systems.

Alperen Kenan, Paul Bremner, Manuel Giuliani

By incorporating force, timing, and multi-segment trajectory handling into standard learning-from-demonstration techniques, robots can generate handwriting that humans perceive as significantly more natural and human-like.

This paper presents a framework for teaching robots to write letters by learning from human handwriting demonstrations. The approach combines force and timing data with trajectory learning to generate robot motions that feel natural to humans. A user study confirmed the generated handwriting was perceived as 71.5% human-like, with the dataset released openly for future research.

Zishan Xu, Zhiyuan Yao, Yuxin Chen et al.

Training agents with internal world rehearsal—where the agent simulates environment responses—is more efficient than external environment interaction and enables better generalization across tool-use tasks.

EnvACE trains AI agents to use tools by having them internally simulate environment responses instead of relying on external simulators. The agent learns to both act and play the environment's role, building an internal world model that predicts what happens after each action. This approach reduces the need for expensive external environments while improving performance on tool-use benchmarks.

Boxiu Li, Zimo Wen, Yijia Fan et al.

A fixed-weight AI system can achieve strong performance on complex tasks (78% on SWE-Bench Pro) by using persistent runtime state, role-based review processes, and verification gates instead of model retraining—showing that intelligent behavior emerges from better control and memory, not just l...

Argus is a runtime system that enables AI agents to tackle complex, long-horizon tasks by persisting through failures and learning from experience.

Zhenran Wang, Zhonghan Bian, Jinsong Li et al.

Current frontier LLMs struggle with social forecasting (max 75/100), and their strengths in probability calibration don't guarantee temporal accuracy—revealing a gap between understanding likelihood and timing in real-world events.

SocietyBench is a benchmark that tests how well LLMs can forecast social events by understanding real-world timelines. It anonymizes events by replacing names and shifting dates to prevent models from relying on memorized information, then scores predictions on probability calibration and temporal accuracy across five real events in Chinese and English.

Zhenran Wang, Zhonghan Bian, Jinsong Li et al.

Current frontier LLMs struggle with genuine prospective forecasting and tend to converge on safe predictions rather than leverage their reasoning capabilities; live benchmarks reveal performance gaps invisible in retrospective evaluations.

Researchers evaluated six frontier LLMs with extended thinking and web search on live FIFA World Cup 2026 predictions before each match occurred, ensuring no data leakage.

Changle Qu, Sunhao Dai, Hengyi Cai et al.

Turn-level hindsight feedback with cross-horizon validation provides denser, more reliable training signals for tool-using AI agents than traditional trajectory-level approaches, improving learning efficiency in long-horizon reasoning tasks.

TurnSight improves how language models learn to use tools by providing better feedback during training. Instead of judging entire sequences at once, it gives turn-by-turn (step-by-step) feedback based on what actually happened, using multiple future perspectives to decide which feedback is most reliable. This helps models learn faster and more accurately in complex multi-step tasks.

Shuhan Xue, Zixin Ding, Yichen Shen et al.

Most agents show some improvement from retained experience, but the gains are uneven and often don't follow the intended learning pathway—suggesting that simply storing information doesn't guarantee agents will use it effectively to improve.

PAST-Bench is a benchmark that tests whether personal AI agents actually improve over time by learning from retained experience across sessions. The benchmark isolates this capability by running agents through task sequences with experience turned on and off, measuring both performance gains and whether improvements follow the intended save-retrieve-update pathway.

Zhen Fang, Yu Zeng, Wenxuan Huang et al.

Multimodal agents need explicit architectural constraints to use visual tools and external knowledge rather than defaulting to text search and internal memory; decoupled perception-exploration pipelines with staged tool unlocking significantly improve performance.

Video-DeepResearch extends multimodal AI agents to handle continuous video streams with web search integration. The system addresses two key problems: agents ignoring visual information in favor of text search, and relying on memorized knowledge instead of actually using tools.

Tianyu Huai, Tingshuo Fan, Xinchi Chen et al.

Current LLM agents show some ability to optimize hyperparameters based on experimental feedback, but struggle with sustained iteration, understanding complex logs, and consistently reaching target performance—revealing gaps between agent reasoning and practical scientific optimization.

AgentHPOBench is a benchmark that tests whether AI agents can optimize machine learning experiments by interpreting results and making informed decisions about hyperparameter changes.

Ilya Mikhelson

Conversational AI can transform assessment from deficit-based grading to mastery-focused evaluation by dynamically adapting difficulty and providing diagnostic feedback in real-time, making testing fairer and more informative.

This paper proposes the 'Socratic Test,' an automated conversational assessment system that replaces traditional static exams with dynamic, multimodal dialogues. By combining Dynamic Assessment, Bloom's Taxonomy, and the SOLO Taxonomy, it measures student learning through graduated scaffolding rather than penalizing mistakes, while reducing anxiety and bias from traditional oral exams.

Qiushi Sun, Kanzhi Cheng, Yian Wang et al.

Vision-language models used to evaluate AI agent trajectories are unreliable judges with systematic leniency bias—but open-source alternatives trained on curated data can match commercial performance at a fraction of the cost.

OSReward is a benchmark and dataset for evaluating how well vision-language models can judge whether computer-using AI agents completed tasks correctly. The researchers found that popular VLM judges have a systematic bias toward being too lenient, and released OS-Shepherd, open-source reward models that match expensive commercial judges at 30-60% lower cost.

Haomin Qi, Xingliang Wang, Xuanqi Gao et al.

By mining repository history and reconstructing code states, you can generate verified, executable coding tasks at scale—reducing the manual effort of creating training data for code-generation agents while maintaining realistic development scenarios.

Change2Task automatically converts pull requests from repository history into executable coding tasks for training AI agents.

Woongkyu Lee, Jungwook Choi

Inference-time scaling helps frontier models but doesn't reliably improve local computer-use agents; success requires failure-aware design and selective compute allocation rather than just adding more computation.

This paper studies how to make computer-use agents (AI systems that control computers) work better on local devices with limited hardware. The researchers test different ways to use extra computation during execution—like remembering more history, planning longer, or trying multiple approaches in parallel—on smaller AI models.

Junlin Yang, Che Jiang, Yu Fu et al.

You can train smaller models to autonomously improve ML code and configurations by teaching them to apply specific program-evolution operators in a loop, enabling practical AI-assisted ML engineering without massive compute.

This paper introduces Frontis-MA1, a 35B AI model trained to improve machine learning engineering tasks through recursive self-improvement. The system uses four core operators (Draft, Improve, Debug, Crossover) to iteratively refine ML solutions, achieving 71% performance on benchmarks—comparable to much larger models—while running on a single GPU with 12GB memory.

Albert Gong, Kyuseong Choi, Abhineet Agarwal et al.

Current frontier LLM agents struggle with production root cause analysis (25% accuracy on realistic scenarios), and this benchmark's controlled 50GB testbed represents a lower bound—real production systems are vastly larger and messier, meaning substantial engineering work remains before AI can...

ORCA-bench is a benchmark that tests how well AI coding agents can diagnose production system failures (root cause analysis) using real telemetry data, logs, and code.

Mao-xun Huang, Jerry Wang, Yi-Cheng Lai et al.

Multi-agent systems can improve performance by dynamically adapting their internal communication structure at inference time, rather than relying on static pre-designed topologies.

MANTA is a framework that lets multi-agent AI systems automatically reorganize how they communicate and work together during execution. Instead of fixing agent roles and communication patterns upfront, MANTA monitors how agents collaborate and adjusts the team structure in real-time when needed—changing who talks to whom, agent responsibilities, and validation steps.

Boning Li, Longbo Huang

Agents can exploit weak opponents much more effectively than Nash equilibrium strategies while maintaining verifiable safety guarantees by self-auditing their strategies before deployment, rather than relying on external safety checks.

This paper presents CS-RNR, a method for game-playing agents to safely exploit flawed opponents while guaranteeing their own safety. The agent tracks opponent behavior patterns, identifies exploitable deviations from equilibrium play, and audits its own counter-strategies before deployment—ensuring every exploit it commits to has been verified to stay within a user-specified safety budget.

Cheng Siong Chin, Jianhua Zhang, Mohan Venkateshkumar

Autonomous systems need to know they're aging: by continuously monitoring hardware health and adapting AI decisions in response, robots can gracefully degrade rather than suddenly fail, especially critical for systems you can't easily repair or replace.

This paper proposes Aging-Aware Autonomous Intelligence (AAAI), a framework that enables autonomous systems to monitor their own hardware degradation and adapt their behavior accordingly.

Hao Fei, Yiran Zhao

To predict human actions accurately, AI systems need to model mental states (beliefs, desires, intentions) as core components of world models, not just physical scene dynamics.

This paper introduces Mental World Modeling (MWM), a framework that extends traditional world models to track not just physical scenes but also the hidden mental states of agents—what they believe, want, and intend.

Peter Kirgis, Sayash Kapoor, Andrew Schwartz et al.

Today's AI agents can handle the engineering work of research but struggle with the creative, strategic, and judgment-based aspects that define actual research progress—suggesting we're far from automating AI R&D despite recent capability improvements.

Researchers tested whether AI agents can conduct open-ended AI research by having them tackle real unpublished research papers over six days with substantial compute.

Peter Tisnikar, Maja Swieczkowska, Benteng Ma et al.

To work effectively with new human or AI partners, estimate their hidden capabilities from a few tasks, then use those estimates to plan collaborative actions—this works better than assuming partners are optimal or pre-training on populations.

This paper tackles ad-hoc teamwork—where an AI agent must collaborate with unknown partners on multiple tasks. The key innovation is inferring hidden partner capabilities (what actions they can reliably execute) without pre-training, then using these estimates to plan better joint actions. The method handles human unpredictability by considering multiple valid strategies, not just optimal ones.

Yihao Chen, Shi Chang, Feng Lin et al.

Breaking program synthesis into explicit specification-first and code-synthesis phases—inspired by requirements engineering—dramatically improves LLM agents' ability to build programs from scratch by preventing early misinterpretations and maintaining behavioral intent.

SpecFirst separates program synthesis into two stages: first, an agent explores a binary and documentation to write a detailed behavioral specification, then a second agent uses that spec to write code. This two-stage approach significantly outperforms single-pass synthesis on from-scratch programming tasks, improving test pass rates by 6.9%-21.3% on ProgramBench.

Jingbo Zhou, Yusai Zhao, Qi Bao et al.

LLM agents are faster and cheaper than humans on office tasks, but they don't yet match human quality—this benchmark lets you measure the cost-quality tradeoff for your use case.

OmegaUse-OfficeVal is a benchmark for testing LLM agents on realistic office tasks (like document editing, spreadsheet work) that take ~2.3 hours of human labor each. It uniquely pairs tasks with economic data—human labor costs and LLM inference costs—so you can directly compare whether AI is cheaper and faster than hiring someone.

Sungjae Park, Shubham Tulsiani

Real-time reactive robot control is possible with diffusion policies by decoupling fast proprioceptive feedback from slower visual processing and adapting the denoising schedule to hardware latency—enabling closed-loop replanning at 25Hz instead of 6Hz.

This paper introduces πR², a method that makes diffusion-based robot manipulation policies reactive and fast enough for real-time control.

Syed Mhamudul Hasan, Anas AlSobeh, Hussein Zangoti et al.

Combining multimodal inputs (images + symptoms) with structured workflow management and safety checks significantly improves disease screening accuracy compared to image-only predictions, and this pattern applies beyond veterinary use.

VetClaw is an edge-cloud system that helps veterinarians screen animals for diseases by combining camera images with symptom descriptions. It uses a vision-language model on a server and intelligent workflow management to collect evidence, validate inputs, apply safety rules, and alert users when cases need escalation—turning a simple image classifier into a practical diagnostic tool.

Abhishek Pillai, Samir Kumar Nayak, Yuan Chen

Current desktop AI agents struggle to verify that their actions caused expected GUI changes—a crucial capability for error recovery and reliable task execution.

This paper introduces Desktop-Delta Bench, a benchmark testing whether computer-use AI agents can understand how desktop GUI changes after actions.

Siyu Xia, Chenheng Zhang, Yanting Wu et al.

By combining retrieval-based and learned memory with automatic routing, UniMem lets AI agents efficiently handle evolving task streams without manual task labels or fixed memory constraints.

UniMem is a memory management system for AI agents that balances two types of memory: episodic (retrieval-based) for new or rare tasks and parametric (learned weights) for recurring patterns. Using learnable routing tokens, it automatically decides which memory type to use for each task, avoiding the need for explicit task boundaries and enabling efficient learning from continuous task streams.

Tianyi Men, Zhuoran Jin, Kang Liu et al.

Long-horizon planning improves most when agents learn explicit world models during pre-training, and multi-teacher distillation works better than single-teacher methods for integrating diverse planning strategies across tasks.

This paper systematically studies how AI agents learn long-horizon planning through three stages: pre-training (what data helps), post-training (GRPO vs OPD methods), and multi-teacher integration (MOPD).

Fabian Kreppel, Reza Salkhordeh, Ferdinand Schmidt-Kaler et al.

Frontier LLMs can automatically generate optimized, production-ready quantum compiler code by iteratively refining specifications, eliminating months of manual engineering work and achieving better performance than expert-written versions.

Researchers used Claude Opus and Claude Fable LLMs to automatically generate Python code for shuttling compilers—software that optimizes how quantum bits move within trapped-ion quantum computers.

Jhonatan Tavori, Gur-Eyal Sela, Ion Stoica et al.

Distributed inference pipelines that merge fast and slow predictions are vulnerable to network-based denial-of-deadline attacks that don't require model access—attackers can degrade accuracy by simply congesting shared resources to miss latency deadlines.

This paper reveals a new vulnerability in distributed inference systems that combine fast local predictions with slower, more accurate remote predictions. Attackers can craft burst-shaped workloads that congest the network, delaying remote predictions past their deadlines so they get discarded.

Darshan Tank, Baran Nama

Skills improve LLM agents less through new capabilities and more through avoiding regressions. Better agent reliability comes from improving how skills ground inputs and verify outputs, not from adding more procedural steps.

When you add skills to an AI agent, it doesn't just help—it can also hurt performance on tasks it previously solved. This paper measures both gains and losses across 6,000 test runs, finding that top-performing skills succeed mainly by causing fewer regressions, not by enabling more wins.

Jiyuan Tan, Vasilis Syrgkanis

Formal verification (Lean proofs) can make AI research automation trustworthy by catching both logical errors and semantic mismatches between formal statements and scientific intent—solving the problem of LLMs accepting fabricated results.

CausalForge automates theoretical research in causal inference by combining a formally verified Lean library (Causalean) with an AI agent pipeline that proposes, formalizes, and proves theorems.

Ritik Raj, Souvik Kundu, Sarbartha Banerjee et al.

For agentic workflows, route once per task using task-level feedback instead of routing each LLM call independently—this lets the system learn which models work best for different task types while optimizing accuracy-latency trade-offs.

TRACE-Router is a routing system that assigns agentic AI tasks to different LLMs once at the start, rather than deciding per-call. It learns which model works best for each task type using delayed feedback from task completion, balancing accuracy and speed. This approach outperforms existing routers by aligning decisions with actual task outcomes.

Xiao Yu, Baolin Peng, Ruize Xu et al.

You can now train agentic AI systems end-to-end with production harnesses and real environments using standard RL tools—no need to build custom training infrastructure for each harness type.

OpenForgeRL is an open-source framework that enables training AI agents end-to-end using complex inference systems (harnesses) like Claude Code and OpenClaw. It works by running a lightweight proxy that intercepts the harness's operations while feeding them into standard RL training systems, and uses Kubernetes to scale training across remote containers.

Fares Fourati, Hinrich Schütze, Eyke Hüllermeier et al.

Automation has conceptual limits: in activities where goals emerge through human-AI interaction (like creative work, learning, or complex decision-making), human participation is constitutive of the outcome itself, not just a workaround for imperfect AI.

This paper argues that human participation in AI systems isn't just a temporary limitation—it's fundamentally necessary in many domains.

Nicolas Kosanovic, Jordan Dowdy, Jean Chagas Vaz

Miniature humanoids can perform complex tele-loco-manipulation (remote control of both movement and arm tasks) by combining VR teleoperation for upper-body control with RL-based locomotion—making advanced robot control accessible beyond expensive full-sized platforms.

This paper develops a control system for miniature humanoid robots that combines virtual reality teleoperation for arm control with reinforcement learning for walking and balance. The system was tested on a small ROBOTIS OP3 robot, demonstrating it could walk while manipulating objects and relocate cubes under human remote control.

Eva McCord, Ernest Pedapati, Zag ElSayed

Building AI-augmented clinical systems requires explicit state machines, privacy-first architecture (self-hosted, encrypted), and deterministic fallbacks—not just bolting AI onto existing workflows.

FMRP-LEAN is a HIPAA-compliant laboratory management system that automates clinical biomarker workflows using AI and structured state tracking. It replaces error-prone spreadsheets with a secure, self-hosted system that tracks samples through multi-day assays, ensures data privacy, and improves communication between lab and clinical teams.

Qijia He, Jiayi Cheng, Chenqian Le et al.

For coding agents, execution feedback from failures creates opportunities for cheap-model recovery that cascade-only systems miss—a learned router with budget calibration can match expensive-model performance while using 35% of the cost.

This paper addresses a key challenge in coding agents: deciding whether to retry a failed task with a cheaper model or escalate to a more expensive one. The authors train a router that learns when cheap recovery attempts are worthwhile based on execution feedback, then add a calibration layer that lets the same router work under different budget constraints without retraining.