mcpchannel.ai — Discover & Use MCPs

Autonomous Agents

Autonomous Agents-research papers. Updated daily. Resources-section-section.

Research papers: 2026 5/5

2026 (5/5), 2026 (4/5), 2026 (3/5), 2026 (2/5), 2026 (1/5), 2025 (4/4),2025 (3/4), 2025 (2/4), 2025 (1/4), 2024, 2023, Earlier

Chronological order.

23rd June 2026

Qwen-AgentWorld: Language World Models for General Agents

Qwen-AgentWorld: introduces a native language world model trained via a three-stage pipeline to simulate agentic environments across seven domains.
The framework utilizes CPT, SFT, and RL to develop a world model that serves as either a decoupled environment simulator or a unified agent foundation model.
Evaluation is performed using AgentWorldBench, which employs an LLM judge and rule-based verifiers to assess simulation fidelity across five dimensions.

MEMPROBE: Probing Long-Term Agent Memory via Hidden User-State Recovery

MEMPROBE: introduces a benchmark that evaluates LLM agent memory as an auditable post-interaction artifact by reconstructing hidden user-state dimensions from the memory store.
The framework utilizes a synthetic user simulator with a hidden, taxonomy-anchored bank to test whether agents can consolidate interaction evidence into recoverable user-state claims.
Experimental results demonstrate that task success is an insufficient metric for memory quality, as agents often fail to form compact, retrievable user models despite successful task completion.

Governed Shared Memory for Multi-Agent LLM Systems

MemClaw: introduces a systems architecture for governed shared memory in multi-agent LLM environments, addressing challenges in scoped access, temporal correctness, provenance, and policy-controlled propagation.
The architecture formalizes the fleet-memory problem and identifies four failure modes: unauthorized leakage, stale propagation, contradiction persistence, and provenance collapse.
The authors instantiate the architecture in MemClaw and validate it using ArgusFleet, an evaluation harness that exercises the memory service against the identified governance failure modes.

Are We Ready For An Agent-Native Memory System?

Agent-Native Memory System Framework: introduces a systematic data management perspective for LLM agent memory by decomposing it into four core modules: memory representation and storage, extraction, retrieval and routing, and maintenance.
The framework evaluates 12 representative memory systems across five benchmark workloads to quantify architectural trade-offs in representation fidelity, retrieval precision, update correctness, and long-horizon stability.
Experimental findings reveal that no single architecture dominates all scenarios, and that cost-efficient maintenance is best achieved through localized updates rather than global reorganization.

World Models in Pieces: Structural Certification for General Agents

Structural Certification for General Agents: introduces a transition-local framework that maps bounded goal-conditioned performance to entry-wise guarantees on an agent's internal world model.
The framework utilizes filtering algorithms to isolate specific transitions where an agent's predictive world model is provably reliable, moving beyond unattainable universal performance guarantees.
By certifying performance on transition-specific LTL goals, the approach enables the safe deployment of general agents by identifying high-fidelity regions within their internal world models.

Data Recipes for Agentic Models

OT-Agent: introduces a comprehensive, open-source data curation pipeline for training agentic models through systematic ablation of six key stages.
The framework utilizes Source Tasks, Mix Tasks, Filter Tasks, Generate Rollouts, Filter Rollouts, and Select Teacher to optimize training data for LLMs.
The project demonstrates that high-quality agentic training data, specifically longer trajectories and diverse task sources, significantly improves LLM performance across multiple agentic benchmarks.

Beyond Bayer: Task-Optimal Sensor Co-Design for Robust Autonomous-Driving Segmentation

Task-Optimal Spectral Mosaic Co-Design Pipeline: introduces a differentiable RAW-to-task framework that optimizes spectral CFA weights while maintaining an identity PSF to maximize task-relevant information for dense prediction.
The framework demonstrates that for dense semantic segmentation, spectral CFA learning provides significant performance gains, whereas PSF co-design is net-negative due to the data-processing inequality.
Empirical results show that a 2×2 CFA tile is optimal, as larger tiles fail to provide additional spectral information while degrading spatial resolution, confirming the rank-three constraint of sRGB inputs.

“Zooming In” on Agentic Web Browsers as Assistive Technologies: A Case Study with a Low-Vision Technology Expert

AWB: introduces a case study evaluating the efficacy of LLM-powered web agents as assistive technologies for users with visual impairments.
The framework utilizes an LLM-based agent to interpret DOM structures and execute autonomous web navigation tasks via natural language instructions.
Findings highlight that while AWBs offer high conversational fluidity, they currently lack sufficient non-visual feedback and user control mechanisms necessary for inclusive assistive technology.

When Helpfulness Overrides Causal Caution: Context-Dependent Suppression and Recovery in LLMs

Causal Caution Framework: introduces a systematic evaluation of LLMs' propensity to withhold causal judgment when empirical evidence is insufficient, utilizing an LLM-as-a-Judge and a PCH scoring rubric to measure context-dependent suppression.
The study demonstrates that practical advisory contexts significantly suppress Causal Caution in LLMs compared to academic contexts, revealing a systematic shift in response patterns driven by pragmatic pressure.
Experimental results show that a minimal self-correction prompt effectively restores Causal Caution, suggesting that the observed decline is a reversible suppression of expression rather than a fundamental capability limitation.

Grading the Grader: Lessons from Evaluating an Agentic Data Analysis System

LAMBDA: introduces a multi-layer evaluation pipeline for agentic data analysis systems that combines automated grading with human calibration to disentangle agent performance from grading artifacts.
The framework utilizes a two-loop wrapper with per-turn instrumentation, incorporating a Programmer-, Inspector- and Nudge-agent to manage conversational outputs and ensure gradable responses.
The evaluation cascade employs a Strict grader, a Lenient grader, and Human inspection to achieve high precision and recall while addressing the challenges of verbose, multi-step agentic outputs.

Accuracy and Satisfaction in Multi-Turn LLM Dialogues for NFR Assessment

PARADISE (PARAdigm for DIalogue System Evaluation): introduces a methodology to evaluate the accuracy and quality of multi-turn dialogues between developers and an LLM-based Agent for assessing Non-Functional Requirements (NFRs) in the iTrust codebase.
The study utilizes an Evaluation Tool and Ground Truth to compare LLM-based Agent outputs against expert assessments, while employing a Satisfaction Survey and Annotation Process to model user satisfaction based on dialogue characteristics.
Findings indicate that while developers perceive the LLM-based Agent responses as high-quality, the actual accuracy against expert ground truth is low, with proactive interactions positively influencing user satisfaction and verbose responses negatively impacting it.

Virtual Simulation for Mental Health

Virtual Simulation for Mental Health: introduces a human-centered framework leveraging Agent-Based Modeling, VR, AR, and LLMs to create safe, controlled environments for mental health experimentation and self-care practice.
The research utilizes Agent-Based Modeling to evaluate matching protocols in online mental health communities and employs VR/AR with LLMs to provide immersive, low-risk spaces for individuals to rehearse stress-management skills.
By combining empirical user needs with simulation-based testing, the dissertation advocates for proactive, safe experimentation to improve mental health technology without disrupting real-world support systems.

SHERLOC: Structured Diagnostic Localization for Code Repair Agents

SHERLOC: introduces a training-free framework that pairs a Reasoning LLM with a compact suite of LLM-friendly Tools and a Self-Recovery Layer to perform structured diagnostic localization for code repair.
The framework utilizes a Tool Executor to mediate repository access, enabling the Reasoning LLM to generate diagnostic findings including root-cause analysis and solution guidance.
SHERLOC improves downstream code repair resolve rates and reduces token consumption by providing actionable diagnostic context to repair agents.

MANGO: Automated Multi-Agent Test Oracle Generation for Vision-Language-Action Models

MANGO: introduces a multi-agent framework that automatically generates fine-grained, executable test oracles for VLA-enabled robots by decomposing natural-language instructions into structured sequences of atomic tasks.
The framework utilizes a collaborative architecture consisting of Generator, Assessor, and Judge agents that iteratively refine generated artifacts through structured feedback to ensure correctness and simulator compliance.
MANGO enables precise failure localization and richer diagnostic information for long-horizon robotic tasks by replacing monolithic symbolic oracles with compositional, fine-grained oracle definitions.

Paying to Know: Micro-Transaction Markets for Verified Product Information in Agentic E-Commerce

Agentic E-Commerce Market Framework: introduces a micro-transaction architecture where LLM-based buyer agents purchase verified product information from sellers and reviewers using programmable payment rails.
The framework shifts the focus of applied NLP from catalogue ranking to cost-aware tool use, negotiation dialogue, and verifiable data acquisition.
This approach incentivizes genuine product quality and competition by treating information as a priced, attestable asset rather than relying on unverified marketing copy.

SupplyNet: Supporting Visual Exploratory Learning in Supply Chain via Contextual Multi-Agent Simulation

SupplyNet: introduces a gamified visual simulation system that leverages a contextual graph-based LLM multi-agent framework to model interdependent supply chain dynamics.
The system integrates an interactive network view, a branching timeline for counterfactual exploration, and a task-oriented analysis console to provide responsive feedback and support structured performance breakdowns.
SupplyNet utilizes LLM agents to simulate human-like business managers, enabling learners to trace causal propagation and test decision strategies within a manipulable decision space.

Automated Summarization of Software Documents: An LLM-based Multi-Agent Approach

Metagente: introduces a collaborative multi-agent system for software documentation summarization that utilizes an Extractor Agent, Summarizer Agent, Teacher Agent, and Prompt Creator Agent to iteratively refine prompts via a Teacher-Student architecture.
The framework employs a dynamic iteration strategy to optimize computational efficiency by halting processing for low-potential samples while maintaining high-quality summary generation.
Empirical evaluation demonstrates that Metagente consistently outperforms single LLM-based agents across diverse datasets, achieving superior semantic alignment and ROUGE scores through structured agent collaboration.

Agentic Collaborative Cognition for Zero-Shot 3D Understanding

Agentic Collaborative Cognition framework: introduces a multi-agent system that reformulates zero-shot 3D understanding as an iterative planning-perception process using a Planning Agent, a Perception Agent, and a shared Holistic Cognitive Map.
The framework utilizes a Planning Agent to perform flexible viewpoint selection and a Perception Agent to document object attributes and refine the Holistic Cognitive Map through closed-loop feedback.
By integrating spatial and semantic information into a shared state, the agents collaboratively resolve 3D scene understanding tasks, including visual grounding, situation estimation, and question answering, with state-of-the-art performance.

SAFARI: Scaling Long Horizon Agentic Fault Attribution via Active Investigation

SAFARI: introduces a tool-augmented diagnostic loop that replaces linear context loading to perform fault attribution on long-horizon agentic trajectories.
The framework utilizes an Investigator Agent that interacts with trajectory traces through iterative tool calls and a persistent Short-Term Memory to maintain diagnostic coherence.
SAFARI decouples diagnostic accuracy from context limits, enabling effective fault attribution even when target faults reside significantly beyond the native context window of LLMs.

Privacy-Preserving RAG via Multi-Agent Semantic Rewriting: Achieving Confidentiality Without Compromising Contextual Fidelity

Multi-Agent Semantic Rewriting Framework: introduces a multi-agent pipeline that sanitizes retrieved documents by extracting privacy-sensitive segments via Pri-Extra Agent, identifying core semantic content through Sem-Extra Agent, and generating safe text using Reconstruction Agent.
The framework utilizes an Asymmetric Retrieval Architecture and Dual-Track Storage Mechanism to physically isolate raw private identifiers from the generation LLM, ensuring zero online inference latency.
By employing deterministic conflict routing, the system effectively balances data confidentiality and contextual fidelity, outperforming existing privacy-preserving baselines in factual consistency across medical and enterprise datasets.

ASALT: Adaptive State Alignment for Lateral Transfer in Multi-agent Reinforcement Learning

ASALT: introduces a multi-agent reinforcement learning framework that utilizes Observation adapter, State adapter, and Transfer module to enable effective knowledge transfer across domains with mismatched state-space dimensionalities.
The framework employs hierarchical multi-head attention and transformer-based encoders to map heterogeneous target-domain inputs into a shared embedding space, facilitating lateral transfer from frozen Source actor and Source critic components to Target actor and Target critic agents.
By jointly training adapters and target agents, ASALT mitigates negative transfer and improves sample efficiency in cooperative multi-agent environments compared to existing baseline methods.

NatureBench: Can Coding Agents Match the Published SOTA of Nature-Family Papers?

NatureBench: introduces a cross-discipline benchmark of 90 tasks distilled from Nature-family publications to evaluate whether AI coding agents can move beyond reproduction toward scientific discovery.
The framework utilizes NatureGym to construct standardized, containerized environments while enforcing an information firewall that forces agents to discover solutions rather than reproduce existing methods.
Evaluation of ten frontier LLM agents reveals that success is primarily driven by methodological translation into supervised prediction problems, with failures largely attributed to suboptimal method choice and insufficient compute budgets.

AGORA: An Archive-Grounded Benchmark for Agentic Workplace Document Reasoning

AGORA (Archive-Grounded Office Reasoning Assessment): introduces a benchmark for evaluating LLM agents on archive-grounded reasoning tasks across eight professional domains using a multi-stage construction pipeline.
The framework utilizes an Agent that interacts with Document Archives via a Bash Tool to perform multi-hop reasoning and compute verifiable numeric answers.
The construction pipeline employs Task Synthesis, Obfuscation, and Refinement, followed by a Difficulty Filter and Human Verification to ensure high-quality, challenging, and leak-free evaluation tasks.

VisCritic: Visual State Comparison as Process Reward for GUI Agents

VisCritic: introduces a visual process reward framework that verifies GUI agent actions by directly comparing pre-action and post-action screenshots in a learned semantic feature space.
The framework utilizes a Siamese Vision Transformer (ViT) Encoder to extract semantic differences, which are then processed by an Action-Aware Critic Head to predict action success, task progress, and error types.
VisCritic operates as a plug-and-play inference-time module that improves GUI agent performance by providing reliable step-level verification without requiring additional human-labeled training data.

Reinforcement Learning for Computer-Use Agents with Autonomous Evaluation

RL-CUA: introduces a reinforcement learning framework that improves Computer-Use Agent robustness by using an autonomous Vision-Language Model evaluator to provide supervision signals.
The framework models evaluator feedback as a noisy binary channel and derives a statistically grounded, asymptotically unbiased reward estimator to enable stable policy optimization.
Empirical results across macOS, Windows, and Linux demonstrate that this noise-correction approach significantly outperforms raw evaluator rewards and zero-shot baselines in task success rates.

Red-Teaming the Agentic Red-Team

Agentic-red-teams: introduces a security analysis of autonomous offensive security systems, identifying critical design flaws that allow attackers to achieve remote code execution on the operator's machine.
The paper defines a full cyber kill chain for these systems, progressing from initial LLM manipulation via agent-phishing to privilege escalation, persistence, and host compromise.
The authors propose a robust, compromise-oriented architecture that enforces strict worker-orchestrator separation, network isolation, and least-privileged execution to mitigate identified attack vectors.

Decentralized Pose Graph Riemannian Optimization for Object-based Multi-Robot SLAM

DRAN (Decentralized Riemannian Approximate Newton): introduces a fully decentralized framework for object-based multi-robot pose graph optimization that leverages an object-trajectory-aware formulation and a decentralized Riemannian approximate Newton solver to achieve communication-efficient, geometry-preserving state estimation.
The framework utilizes a dynamic map consensus mechanism to ensure global map consistency across sparse, time-varying communication topologies while employing the Schur complement method to efficiently decouple and optimize high-dimensional private robot trajectories and shared public object poses.
By constructing local Riemannian approximate Newton models, the approach provides curvature-preconditioned updates that significantly reduce communication overhead and iteration counts compared to first-order Riemannian descent methods.

The Latent Bridge: A Continuous Slow–Fast Channel for Real-Time Game Agents

Latent Bridge: introduces a learned continuous channel that projects slow model residuals into the fast LLM's input-embedding space to enable real-time agent deliberation.
The framework couples a frozen reactive LLM with a frozen reasoning LLM, using a trainable bridge MLP to prepend latent tokens to the fast model's input sequence.
The Latent Bridge improves performance on planning-heavy tasks where slow reasoning provides a benefit over reactive-only control, while avoiding the latency overhead of text-based coupling.

Varying Bundle Size Reactive Multi-Task Assignment using Selective Cost Estimation for Multi-Agent Systems

VBS-RMTA: introduces a two-stage, multi-fidelity bundle generation approach that utilizes a Central Coordinator, Agent Local Search Tree, Euclidean Heuristic, High-Fidelity Path Planner, Priority Queue, Local Lookup Table, and Set-Packing Integer Program to enable scalable, reactive multi-robot task allocation.
The framework employs a depth-limited beam search with a Euclidean Heuristic to generate candidate bundles, followed by a best-first refinement process using a High-Fidelity Path Planner to ensure computational efficiency.
By offloading cost estimation to individual agents while maintaining a centralized Set-Packing Integer Program, the architecture preserves agent anonymity and ensures global feasibility in dynamic environments.

Bayesian Control for Coding Agents

Bayesian Control for Coding Agents: introduces a cost-sensitive sequential hypothesis-testing framework that uses a Bayesian Controller to manage code generation, criticism, and verification.
The framework models the orchestration problem as a Partially Observable Markov Decision Process (POMDP) to optimize expected utility by maintaining a Belief State over candidate correctness.
The approach utilizes a Generator Agent, multiple Critic Agents, and an Oracle Verifier to dynamically decide whether to refine, verify, or stop based on the calculated value of information.

NoContactNoWorries: Estimating Contact through Vision and Proprioception for In-Hand Dexterous Manipulation

NoContactNoWorries: introduces a transformer-based multimodal framework that fuses RGB-D vision with proprioception to infer binary contact states as a pseudo-tactile signal for dexterous manipulation.
The framework utilizes a frozen RGB-D Encoder, Proprioceptive Embeddings, a Cross-Attention Module, a Causal Transformer Encoder, and a Contact Head to enable contact-aware control without physical tactile sensors.
Experimental results demonstrate that the predicted contact signals effectively substitute for tactile feedback in downstream reinforcement learning policies, achieving robust sim-to-real transfer on both seen and novel objects.

Agentic Generation of AST Transformation Rules for Fixing Breaking Updates

BIGBAG: introduces an agentic framework that generates reusable, structured, and executable AST transformations to automatically repair breaking dependency updates in Java projects.
The framework utilizes a generate-apply-verify loop where a coding agent leverages AST transformation engines, such as Spoon or JavaParser, to synthesize repair logic that transfers across multiple client projects affected by the same dependency update.
Experimental results across 157 breaking updates demonstrate that the choice of AST transformation engine significantly impacts repair success, with the best configuration achieving a 78.6% fix rate and 33.3% cross-project transferability.

ReM-MoA: Reasoning Memory Sustains Mixture-of-Agents Scaling

ReM-MoA: introduces a memory-augmented Mixture-of-Agents framework that sustains inference-time scaling by utilizing a Ranked Reasoning Memory and a Curated Diversified Memory Routing scheme to preserve reasoning quality and exploration diversity across layers.
The framework includes proposer agents, a comparative Reviewer Agent, and an aggregator, which collectively leverage cross-layer reasoning memory to prevent the performance degradation and saturation observed in standard MoA architectures.
Optional frontier-model distillation further enhances the Reviewer Agent, enabling the system to maintain performance gains across diverse reasoning benchmarks as depth and width scale.

Detecting AI Coding Agents in Open Source: A Validated Multi-Method Census of 180 Million Repositories

Multi-layered detection framework: introduces a comprehensive approach to identify AI coding agents across 180 million repositories by integrating four distinct detection methods: Type A (bot account), Type B (message signature), Type C (distributed human attribution), and Type D (configuration-file scanning).
The framework leverages the World of Code infrastructure to perform a multi-method union, revealing that single-signal detection methods significantly undercount AI activity, with some agents showing up to a 30x relative-recall gap.
The research validates the detection taxonomy through hand-labeled samples and demonstrates that AI agent adoption is bimodal, characterized by either "born-with-AI" greenfield projects or legacy integration.

Escaping the Self-Confirmation Trap: An Execute-Distill-Verify Paradigm for Agentic Experience Learning

EDV (Execute-Distill-Verify): introduces a collaborative experience learning framework that decouples execution, distillation, and validation to mitigate the Self-Confirmation Trap in LLM agents.
The framework utilizes a Heterogeneous Agent Pool to generate diverse trajectories, a Distillation Agent for comparative analysis, and a Verification Group for consensus-based filtering before memory insertion.
EDV maintains an Ability Matrix and a hierarchical memory structure (Shared/Private Memory Bank) to optimize task-solver matching and improve long-horizon reasoning reliability.

Agentic AI for Bilevel Long-Term Optimization of Policy-Driven Physical Layer Systems

Agentic-LTPO: introduces a nested bilevel optimization framework that decouples long-term policy-driven configuration from latency-sensitive physical layer control using a multi-agent architecture.
The upper level employs Policy Interpreter Aint, Network Observer Aobs, Configuration Planner Aplan, and Performance Critic Acrit to translate evolving operator intents into structured parameters, supported by a RAG module for evidence-based refinement.
The lower level utilizes a closed-form zero-forcing beamforming solver to ensure real-time feasibility and optimality under instantaneous channel conditions and upper-level constraints.

Poisoned Playbooks: Demystifying Knowledge Poisoning Effects on AI Security Agents

Poisoned Playbooks: introduces a systematic empirical study on how crafted security write-ups injected into public knowledge sources can manipulate the behavior of RAG-based AI security agents.
The research defines the Verification Boundary (VB) as a three-level classification system that determines whether an LLM agent will reject, evaluate, or adopt poisoned claims based on available evidence.
The study demonstrates that while mitigation strategies like verification prompting and multi-source retrieval help, they remain insufficient in sparse-evidence or zero-day vulnerability scenarios where the agent lacks contradictory information.

ATRIA: Adaptive Traceable ECG Reporting with Iterative Agents

ATRIA (Adaptive Traceable ECG Reporting with Iterative Agents): introduces a multi-agent system that mimics clinical ECG reporting workflows by utilizing an Orchestrator Agent, Analysis Agent, Report Agent, Literature Agent, Review Agent, and a Shared Artifact Store to enable iterative, traceable report generation.
The framework decouples ECG interpretation from reporting through staged handoffs, allowing clinicians to verify, revise, and augment findings mid-session without re-executing the entire pipeline.
By binding every report claim to supporting evidence and maintaining a persistent artifact store, the system ensures clinical trustworthiness and supports complex tasks like comparative ECG analysis and lab-augmented reporting.

Managing Task Execution for Unknown Workloads in Batteryless IoT: A Hardware-Agnostic Evaluation

Batteryless IoT Task Scheduling Framework: introduces hardware-agnostic dynamic scheduling strategies for batteryless IoT devices by treating applications as black boxes and managing energy budgets through Reinforcement Learning Agent, Approximated Prediction Method, and AIMD-MIAD Controller.
The framework utilizes a physically accurate simulation environment to evaluate trade-offs between task throughput, system resilience, and recovery times across varying capacitor sizes.
The research demonstrates that while advanced dynamic strategies provide critical resilience for constrained systems, simpler static policies remain effective for devices with larger energy buffers.

RoBoSR: Structured Scene Representations for Embodied Robotic Reasoning

RoBoSR: introduces an embodied intermediate representation that formulates manipulation as step-wise state transitions over semantically grounded, object-centric scene graphs using Qwen3-8B, SAM3, SKIL, Manip-Cognition-1.6M, Scene Graph, RGB-D Observation, and Action Expert.
The framework disentangles high-level task reasoning from raw inputs by utilizing a structured scene graph as the primary state space for decision-making and causal state evolution.
RoBoSR employs a two-stage training process, combining supervised fine-tuning with reinforcement fine-tuning to enforce execution consistency and improve long-horizon task planning.

Securing LLM-Agent Long-Term Memory Against Poisoning: Non-Malleable, Origin-Bound Authority with Machine-Checked Guarantees

TMA-NM (Tamper-evident Memory Authority, Non-Malleable): introduces a structural defense for LLM agents that binds memory authority to its origin at write time to prevent poisoning via laundering transformations.
The framework utilizes a TMA-NM monitor to enforce non-malleable information-flow control, ensuring that untrusted memory cannot trigger consequential actions without independent trusted corroboration.
Empirical evaluation across eight frontier models demonstrates that TMA-NM achieves zero attack success on memory poisoning while maintaining full legitimate utility, outperforming content- and lineage-based defenses.

AutoSpec: Safety Rule Evolution for LLM Agents via Inductive Logic Programming

AutoSpec: introduces a framework that automatically evolves expert-designed safety rules for LLM agents using counterexample-guided inductive synthesis (CEGIS) and inductive logic programming (ILP) to maintain high precision and recall.
The framework iteratively mines false-positive and false-negative counterexamples from execution traces, uses ILP to identify discriminating predicates, and applies constrained edit operators to refine symbolic guardrails.
AutoSpec achieves significant improvements in safety rule F1 scores across code-execution and embodied agent domains while producing human-readable, auditable, and generalizable rules.

SP-Mind: An Autonomous Reasoning Agent for Spatial Proteomics Analysis

SP-Mind: introduces an autonomous reasoning agent that unifies spatial proteomics analysis by dynamically chaining specialized computational tools through expert-curated skill templates and a ReAct-style reasoning loop.
The framework utilizes a dual-layer memory architecture and a Python-to-Container Bridge to ensure reproducible, multi-step execution across heterogeneous computing environments.
SP-Mind is evaluated on SP-Bench, a comprehensive hierarchical benchmark, where it demonstrates state-of-the-art performance in orchestrating complex, end-to-end spatial biology workflows.

SkyChain Intelligence: A Blockchain-Secured Multi-Agent DRL Framework for Low-Altitude Embodied Artificial Intelligence

SkyChain Intelligence: introduces a holistic framework that synergistically integrates agentic AI, consortium blockchain, and MADRL to address the trilemma of autonomy, security, and efficiency in low-altitude computility networks.
The framework utilizes a hybrid-action MADRL algorithm with a dual-head actor-critic architecture to jointly optimize task offloading, resource allocation, and 3D trajectory control.
A lightweight consortium blockchain with a dynamic reputation mechanism and smart contracts provides a decentralized trust layer that is deeply fused into the MADRL reward function to incentivize secure and reliable agent cooperation.

An Introduction to Causal Reinforcement Learning

CRL (Causal Reinforcement Learning): introduces a framework that integrates causal inference with reinforcement learning to develop more robust, sample-efficient, and explainable decision-making systems.
The framework utilizes SCMs to explicitly model environment mechanisms and the Pearl Causal Hierarchy to categorize learning tasks based on observational, interventional, and counterfactual interactions.
CRL addresses challenges in standard RL by leveraging causal diagrams and structural assumptions to enable principled policy learning under uncertainty and unobserved confounding.

MedBench v5: A Dynamic, Process-Oriented, and Hallucination-Aware Benchmark for Clinical Multimodal Models

MedBench v5: introduces a dynamic, process-oriented benchmark for clinical multimodal models that evaluates reasoning trajectories rather than static outcomes.
The framework utilizes a dual-dimensional approach combining Clinical Cognitive Responsiveness and Medical Atomic Skills to assess broad capabilities and specific operational procedures.
It incorporates a stress-audit-tracing protocol with information-flow stressors and hallucination propagation monitoring to localize reasoning failures and analyze the evolution of unsupported claims.

Autonomous Video Generation with Counterfactual Controllability for Self-Evolving World Models

Self-Evolving World Model framework: introduces a closed-loop architecture for autonomous video generation that optimizes four stages—Generation (proposes intervention-conditioned future frames), Binding (conditions frames on embodiment constraints), Verification (calibrates predictions under distribution shift), and Distillation (compresses futures into decision variables)—to achieve counterfactual controllability.
The framework utilizes a self-evolving feedback loop where distilled action knowledge is returned to the Generation stage to iteratively improve the quality and action-validity of imagined futures.
The approach evaluates performance using four specific metrics—Novelty, Consistency, Out-of-Distribution, and Efficiency—to ensure that generated video sequences are not only plausible but also physically actionable for embodied agents.

Metis: Bridging Text and Code Memory for Self-Evolving Agents

Metis: introduces a hierarchical dual-representation memory system that balances the broad applicability of text memory with the execution efficiency of code memory for self-evolving agents.
The framework utilizes Differentiated Text Reflection to organize experience into plans, facts, and pitfalls, while employing Pattern-Aware Code Generation to selectively crystallize recurring plans into validated callable tools.
Metis incorporates a Memory Manager for joint selection of text and code, and a Reflection Harness to ensure dependency closure and safe tool admission, significantly improving task accuracy and execution efficiency.

OmniPath: A Multi-Modal Agentic Framework for Auditing Wheelchair Accessibility

OmniPath: introduces a proactive agentic framework that fuses OpenStreetMap topology with high-resolution aerial LiDAR to audit pedestrian environments for wheelchair accessibility.
The framework utilizes a Geometric Perception Engine and Agent A to perform micro-scale segmentation and quantify physical friction points like running slopes, cross slopes, and vertical discontinuities.
By calculating a weighted severity score for each 0.5-meter segment, the system identifies accessibility barriers and provides actionable intelligence for urban infrastructure remediation.

DramaDirector: Geometry-Guided Short Drama Generation

DramaDirector: introduces a geometry-grounded framework that decouples short-drama generation into structured storyboard planning and retrieval-augmented video synthesis.
The framework utilizes a gallery of real short-drama shots to provide depth and pose references, which guide the first-frame generator and ensure cinematographic consistency.
DramaDirector employs multi-task supervised finetuning and GRPO-based reinforcement learning to align LLM-generated storyboards with real-world visual priors and narrative requirements.

Universal Guideline-Driven Image Clustering via a Hybrid LLM Agent

Guideline-Driven Clustering Agent: introduces a training-free framework that performs universal image clustering by utilizing GCPM to generate guideline-aware embeddings and MST-based LLM Traversal for selective semantic merging.
The framework employs MLLMs to extract concept proxy captions, which are subsequently encoded by instruction-aware embedders to achieve attribute disentanglement and guideline adherence.
To ensure computational efficiency, the system uses HDBSCAN for initial clustering and an MST-based traversal algorithm that minimizes LLM invocations to O(N log N) while maintaining high semantic precision.

Breaking the Filter Bubble: A Semantic Pareto-DQN Framework for Multi-Objective Recommendation

Pareto-DQN: introduces a multi-objective reinforcement learning framework that formalizes recommendation as a semantic multi-objective Markov decision process to mitigate filter bubbles.
The architecture integrates high-fidelity semantic embeddings with a Pareto-DQN agent to treat engagement, diversity, and fairness as distinct, non-aggregable reward signals.
By utilizing hypervolume-based action selection, the framework effectively maps the Pareto frontier, enabling responsible recommendations with minimal impact on user engagement.

Can Language Model Agents be Helpful Circuit Explainers in Mechanistic Interpretability?

HYVE (Hypothesize, Validate, Explain): introduces an agentic framework that explains localized transformer circuits through an iterative loop of Observation, Hypothesis Generation, Hypothesis Validation, Classification, and Summarization.
The framework utilizes LLM backbones to perform mechanistic interpretability research by generating grounded hypotheses and testing them through automated causal interventions and code execution.
The authors introduce AGENTICINTERPBENCH, a benchmark comprising 84 semi-synthetic transformer circuits, to evaluate the sufficiency and reliability of LLM agents in circuit explanation.

Submodular Welfare Maximization with Budget Constraints in the Random-Order Model

SGAP introduces a constant-competitive online algorithm for submodular welfare maximization under budget constraints in the random-order model using InfeasibleSubGAP and FeasibleSubGAP.
The framework utilizes a continuous greedy algorithm to compute fractional assignments, which are then converted into feasible integral assignments via randomized selection.
The approach achieves a competitive ratio of approximately 1/14.85 for the general problem and improves existing bounds for the submodular secretary matching special case.

FlowDec: Temporal Conditional Flow Decorruptor for Robust Continuous Vision-Language Navigation

FlowDec: introduces a navigation-aware image restoration framework that utilizes latent conditional flow matching to mitigate visual corruptions in continuous environments.
The framework integrates a hybrid temporal conditioning strategy and action-centroid guided filtering to ensure temporally consistent and physically meaningful image reconstruction for LLM-based navigation agents.
By decoupling robustness enhancement from the navigation backbone, FlowDec achieves real-time performance and improved navigation success across diverse unseen visual corruptions.

Knowledge-Graph Grounding Helps LLMs Only for Out-of-Training Knowledge: A Controlled Study on Clinical Question Answering

Samyama-graph framework: introduces a controlled study evaluating how structured knowledge-graph grounding impacts LLM performance across in-training and out-of-training knowledge regimes.
The research demonstrates that grounding provides no significant performance lift for in-training data but yields substantial accuracy improvements for out-of-training facts.
The study establishes a knowledge-boundary law, showing that grounding is only effective when the decisive information is absent from the LLM's parametric memory and not reconstructible from surface structure.

Skills for the future software profession: beyond agentic AI!

Agentic Software Engineering Workflow: introduces a framework for future software development that shifts human focus from manual coding to orchestrating specialized AI agents and managing machine-checkable V&V artifacts.
The framework integrates a Coding Agent, Verification Agent, and Testing Agent to automate software production while requiring human oversight for requirement distillation and architectural decision-making.
It emphasizes mitigating cognitive debt by maintaining structured repositories of requirements, specifications, and agent trajectories to ensure long-term system understanding and accountability.

22nd June 2026

Semantic Browsing: Controllable Diversity for Image Generation

Semantic Browsing: introduces an agentic workflow that organizes image generation into a hierarchical tree of semantically distinct, user-interpretable variations.
The framework utilizes a multi-agent system comprising a Context Analyst, Brainstormer, Decision Maker, and Critic to iteratively expand a scene interpretation tree while ensuring structural integrity and plausibility.
By decoupling semantic decision-making from pixel generation, the method enables systematic exploration of diverse design spaces without relying on stochastic sampling.

MAS-PromptBench: When Does Prompt Optimization Improve Multi-Agent LLM Systems?

MAS-PromptBench: introduces a systematic benchmark for evaluating system-prompt optimization across diverse multi-agent LLM system configurations, including LLM-based agents, coordination harness, prompt optimizers, task distribution, workflow topology, communication protocol, and team size.
The research quantifies prompt-optimization gains using MAS-GEPA and MAS-MIPRO, revealing that performance improvements are highly sensitive to task structure, communication protocols, and coordination topologies.
Findings indicate that prompt optimization is most effective for tasks with explicit, verifiable local behaviors and when communication protocols impose structured, clear interaction patterns.

EnterpriseClawBench: Benchmarking Agents from Real Workplace Sessions

EnterpriseClawBench: introduces a benchmark constructed from real-world enterprise agent sessions that converts proprietary workplace data into reproducible tasks for evaluating LLM-based agents.
The framework utilizes a multi-stage pipeline including mechanical filtering, prompt rewriting, and taxonomy-based packaging to create 852 benchmark tasks with associated hard rules and semantic rubrics.
Evaluation is performed across harness-model combinations, measuring performance through artifact delivery, cost, runtime, and skill-transfer behavior using both text and visual LLM judges.

Causal Discovery in the Era of Agents

causal-learn+: introduces an agentic framework that coordinates causal discovery workflows while strictly isolating LLMs from the formal inferential core to prevent hallucinated causal evidence.
The system utilizes Agentic Assistants to manage Data Analysis, Preprocessing Guidance, Algorithm Recommendation, Expert Knowledge Incorporation, Tool Coordination, and Result Interpretation, ensuring all causal claims remain grounded in data and explicit algorithms.
By maintaining a Protected Inferential Core, the framework ensures that LLMs provide only context and guidance, leaving the final causal discovery to provably-correct algorithms and user-approved decisions.

Decentralized Autonomous Traffic Management through Corridor Networks

MARL (Multi-Agent Reinforcement Learning) framework: introduces a decentralized approach for autonomous aircraft traffic management in structured corridor networks using MARL-based decentralized policy, rotation-invariant observation representation, curriculum-based training, local sensing neighborhood, and planar fixed-wing kinematic model.
The framework enables aircraft to perform zero-shot transfer to complex multi-corridor networks by relying solely on local observations and interaction data without centralized coordination.
Experimental results demonstrate that the learned policies maintain high corridor conformance and stable traffic flow across varying densities and heterogeneous vehicle fleets.

Kamera: Unified Position-Invariant Multimodal KV Cache for Training-Free Reuse

Kamera: introduces a position-invariant KV caching framework that enables training-free reuse of multimodal context by separating content from position and applying a low-rank conditioning patch to restore cross-chunk binding.
The framework utilizes a canonical KV store and an exact RoPE relocation operator to eliminate redundant re-prefills, while a rank-m conditioning patch corrects the diffuse, deep-layer deficit caused by cross-chunk dependencies.
Kamera achieves near-ceiling accuracy across diverse LLM architectures (MLA, GQA, MHA) by treating context as a set of reusable chunks, enabling efficient window operations like reordering, sliding-window survival, and reversible eviction.

HoloAgent-0: A Unified Embodied Agent Framework with 3D Spatial Memory

HoloAgent-0: introduces a unified embodied agent framework that organizes heterogeneous robot capabilities into a closed-loop workflow using Embodied AgentOS, Memory Layer, and Skill Layer.
The framework utilizes a persistent 3D spatial memory and a typed skill interface to enable reliable long-horizon task execution across diverse robot embodiments.
HoloAgent-0 connects cloud-level reasoning with on-device execution, providing feedback-driven re-planning and monitoring through a standardized ROS2 command/status interface.

VeriEvol: Scaling Multimodal Mathematical Reasoning via Verifiable Evol-Instruct

VeriEvol: introduces a scalable framework that transforms low-difficulty image-question seeds into verified training samples using Prompt Difficulty Control and HTV-Agent to ensure high-quality data for LLMs.
The framework decouples prompt evolution from answer verification, utilizing route-specific operators to increase difficulty and a hypothesis-test verifier to enforce answer reliability before policy updates.
VeriEvol enables monotonic scaling of visual mathematical reasoning performance by providing a traceable, auditable pipeline that integrates seamlessly with existing GRPO-style RL recipes.

Self-Compacting Language Model Agents

SELFCOMPACT: introduces a training-free scaffold that enables LLMs to perform adaptive context compaction by pairing an inline Compaction Tool with a Lightweight Rubric to determine optimal summarization timing.
The framework utilizes a Reasoning Trajectory to guide the LLM-Agent in deciding when to invoke the Compaction Tool, effectively mitigating context rot without requiring external supervision or fine-tuning.
By leveraging KV Cache reuse, the approach achieves significant token cost reductions while maintaining or exceeding performance compared to fixed-interval summarization methods across various agentic and reasoning benchmarks.

Concordia: JIT-Compiled Persistent-Kernel Checkpointing for Fault-Tolerant LLM Inference

Concordia: introduces a GPU-resident persistent kernel that enables transparent, fault-tolerant LLM inference by combining PTX/SASS instrumentation, JIT-compiled checkpoint handlers, and append-only recovery logging.
The framework utilizes a Persistent Kernel Executor to perform dirty-page detection at HBM bandwidth, significantly reducing checkpoint latency compared to host-side scanning.
Concordia integrates with existing LLM serving stacks via an NCCL Wrapper and provides a unified recovery contract that supports cross-architecture migration and rapid failure restoration.

AOHP: An Open-Source OS-Level Agent Harness for Personalized, Efficient and Secure Interaction

AOHP: introduces an OS-level agent harness built on AOSP that treats agents as first-class actors to enable personalized service composition, efficient agent interfaces, and secure information flow.
The architecture replaces app-centric workflows with an agent-native design, utilizing a unified interaction interface and system-managed memory to facilitate cross-app task execution.
Empirical results demonstrate that AOHP significantly improves task completion rates while reducing LLM token consumption and execution time compared to stock Android.

Detecting Malicious Agent Skills in the Wild using Attention

Locate-and-Judge: introduces a two-stage pipeline that detects malicious LLM agent skills by using a small reader LLM to localize suspicious spans via attention ranking, followed by a zero-shot LLM judge to classify them.
The framework significantly reduces computational costs by focusing the expensive judge component only on the top-K spans identified by the lightweight locator.
Evaluated on 134k marketplace skills, the approach effectively identifies hidden malicious skills that evade traditional scanners by leveraging instruction-following attention as a robust signal for injection.

REASONINGLENS: Hierarchical Visualization and Diagnostic Auditing for Large Reasoning Models

REASONINGLENS: introduces a multi-granularity framework for the hierarchical visualization, automated diagnostic auditing, and systemic profiling of long CoT traces in LLMs.
The framework utilizes Hierarchical Visualization to structure reasoning into interactive graphs, Agentic Diagnosis to identify errors via Memory, Verification, and Suggestion modules, and Systemic Profiling to analyze model-level reasoning bottlenecks.
The authors also introduce LENSBENCH, a unified benchmark comprising 130 verified instances to evaluate structural visualization fidelity and the accuracy of automated reasoning error detection.

Litmus: Zero-Label, Code-Driven Metric Specification for Evaluating AI Systems

Litmus: introduces a zero-label system that derives justified, per-stage evaluation and monitoring portfolios by interrogating source code and practitioner intent to establish explicit metric-design constraints.
The framework utilizes a multi-stage pipeline comprising static analysis, LLM-based architecture reconstruction, adversarial criticism, and goal elicitation to ground metrics in specific system components and failure surfaces.
Litmus outperforms existing evaluation methods by providing broader coverage, near-zero redundancy, and superior label validity across diverse, code-defined AI pipelines without requiring manual labeling at design time.

Superhuman AI for Generals.io Using Self-Play Reinforcement Learning

Generals.io AI Framework: introduces a superhuman agent for real-time strategy games trained via self-play reinforcement learning using a JAX-native simulator, a transformer policy, a value head, a policy head, an exponential moving average, and top-advantage filtering.
The architecture utilizes a transformer torso to process spatial game observations and temporal scoreboard statistics, enabling effective decision-making under imperfect information.
The research demonstrates that generic policy-gradient methods, when combined with high-throughput simulation and specific training stabilizers, can achieve superhuman performance without human demonstrations or complex reward shaping.

Group selection promotes prosocial prompts in populations of LLM agents

Multi-agent simulation framework: introduces a multi-generational evolutionary environment where LLM agents optimize natural-language strategy strings through individual or group-level selection.
The framework utilizes a donor game to evaluate agent performance, applying either individual- or group-level fitness metrics to determine which strategies are transmitted to subsequent generations.
Empirical results demonstrate that group selection effectively sustains cooperative behavior in LLM populations, while individual selection leads to the dominance of self-interested strategies and collective defection.

VideoAgent: All-in-One Framework for Video Understanding and Editing

VideoAgent: introduces an all-in-one agentic framework for automated video understanding and editing that addresses long-form video planning and multi-agent orchestration challenges.
The framework utilizes a shot planning agent for coherent narrative structure and a textual-gradient graph optimization mechanism to dynamically compose and refine complex editing pipelines.
VideoAgent integrates over thirty specialized editing agents and achieves high orchestration success rates while significantly reducing API costs compared to existing LLM-based systems.

TMAX: A simple recipe for terminal agents

TMAX: introduces a scalable, difficulty-aware synthetic data generation pipeline and a reinforcement learning recipe for training terminal-using agents.
The framework utilizes a compositional Data Pipeline to create diverse RL environments, which are then used to train an LLM Policy via DPPO Trainer within a Docker Sandbox.
TMAX-9B achieves state-of-the-art performance among open-weight models under 10B parameters on Terminal-Bench 2.0, demonstrating effective generalization across tasks and harnesses.

Test-Driven, AI-Assisted Learning: Replacing Lectures with Weekly Closed-Book Tests

TDAA (Test-Driven, AI-Assisted Learning): introduces a pedagogical framework that replaces traditional lectures with a weekly cycle of self-paced study and strict closed-book tests, supported by a course-materials harness.
The framework utilizes a course-materials harness, which integrates an AI writer, AI reviewer, and human approval process to automate the production of learning sheets, validation sheets, and tests at scale.
By shifting the instructor's role from routine lecturing to designing learning paths and verifying AI-generated content, the model ensures accountability and operational feasibility in proof-heavy courses.

EHR-Complex: Benchmarking Medical Agents for Complex Clinical Reasoning

EHR-Complex: introduces a large-scale benchmark for interactive clinical database reasoning, utilizing a MIMIC-IV substrate to evaluate LLM agents on complex, multi-table, and longitudinal EHR analysis tasks.
The framework employs a construction pipeline that transforms patient records into a Patient Event Graph, extracts Clinical Evidence Paths, and performs SQL Compilation to generate execution-validated tasks.
Evaluation of LLM agents on EHR-Complex reveals significant challenges in population-level reasoning, medical-code grounding, and SQL logic, highlighting the necessity for robust, interactive clinical reasoning capabilities.

IOI: Decoupling Kinematics and Physics for Interactive World Models

IOI: introduces a hybrid interactive world model that decouples deterministic robot kinematics from stochastic environmental dynamics to improve simulation fidelity.
The framework utilizes a URDF-based kinematic solver and multi-view orthographic renderer to provide geometry-consistent guidance to a diffusion-based video generator.
By integrating analytical kinematic priors via the MKAI module, IOI mitigates action deviation and state implausibility, achieving robust performance in policy evaluation and OOD generalization.

Towards Root Memories: Benchmarking and Enhancing Implicit Logical Memory Retrieval for Personalized LLMs

RootMem: introduces a plug-and-play framework that distills raw user histories into structured Root Memory Units to complement semantic retrieval with personalized decision logic.
The framework utilizes a collaborative Generator-Judger-Refiner pipeline to construct the IMLogic benchmark, which evaluates the ability of LLMs to retrieve logically critical but semantically distant memories.
RootMem employs a Root Memory Router to identify relevant units based on Execution Rules and Personalized Logical Evidence, significantly improving the accuracy of LLMs in implicit logical retrieval tasks.

GIF: Locally Sound Geometric Information Flow Control for LLMs

GIF (Geometric Information Flow): introduces a semantic framework for tracking information flow in LLMs by using the Jacobian and local output geometry to upper-bound Shannon mutual information between input spans and model outputs.
The framework utilizes a locally faithful Gaussian surrogate channel to provide a scalable, sound, and quantitative measure of information flow that avoids the overtaint problems of traditional IFC.
GIF enables efficient, fine-grained security enforcement in agentic systems by surfacing policy-relevant input spans for declassification, significantly reducing token costs compared to full-trajectory LLM judges.

Dynamic multi-agent deep reinforcement learning-based pricing and incentivization approach in multimodal transportation networks

Multi-agent deep reinforcement learning framework: introduces a dual-agent approach that reconciles conflicting objectives between public authorities and profit-driven ridesharing providers through coordinated dynamic pricing and incentivization.
The framework integrates a multimodal macroscopic simulation with two RL agents, where the public authority manages PT incentives to improve system-wide efficiency and equity, while the ridesharing provider adjusts fares to maximize revenue.
Numerical experiments on the Sioux Falls network demonstrate that an equity-oriented dynamic policy achieves the best trade-off between efficiency, environmental impact, and profitability compared to static baseline strategies.

Wireless Personal Agent: Extending Wireless Intelligence from Networks to Terminals

WISPA (Wireless Intelligent Self-evolving Personal Agent): introduces a terminal-side resource management framework that decouples latency-sensitive online execution from offline LLM agent reflection to achieve personalized wireless connectivity.
The framework utilizes an Online Executor for deterministic, lightweight decision-making and an Offline LLM Agent, comprising an Observation Module, Reflection Module, and Strategy Module, to refine user-specific preference parameters based on historical usage.
By confining LLM-based reasoning to offline idle windows and employing a bounded parameter update mechanism, the system ensures real-time reliability while adapting to dynamic user preferences and environmental conditions.

RS-Gen: A Multi-Stage Agentic Framework for Reasoning and Search-Augmented Image Generation

RS-Gen: introduces a multi-stage agentic framework that reconstructs image generation into a collaborative "questioning-and-solving" workflow using Conversation Memory, Image Router Agent, Intent Analysis Agent, Reasoning & Search Agent, and Image Generation Agent.
The framework utilizes a Tool Hub and Expert Toolset to integrate external knowledge and logical reasoning, effectively bridging the gap between static model training and real-world complex visual tasks.
RS-Gen employs a "Generate-Review-Correct" closed-loop mechanism within its Image Generation Agent to ensure high-fidelity, logically consistent outputs through iterative self-correction.

MuPPET: A Benchmark for Contextual Privacy of LLM Assistants in Multi-Party Conversations

MuPPET (Multi-Party Privacy Exposure Testing): introduces a benchmark for evaluating contextual privacy risks of LLM assistants in multi-party conversational environments.
The framework utilizes LLM-as-a-judge to assess privacy leakage and utility by analyzing model responses against user-specific memories and shared group context.
Experimental results demonstrate that LLMs frequently leak sensitive information in multi-party settings, with smaller open-weights models exhibiting the highest vulnerability.

Memory Contagion: Cross-Temporal Propagation of Evaluator Bias via Agent Memory

Memory Contagion: introduces a formal framework to analyze the cross-temporal propagation of evaluator bias through agent memory systems, where biased experiences stored by a source agent influence the performance of future target agents.
The framework decomposes contagion into content-based and retrieval-based components, demonstrating that biased input is a sufficient cause for contagion even under perfect oracle consolidation.
Experimental results reveal that consolidation effects are bias-type-dependent, where LLM-based summarization attenuates global length bias but amplifies local authority bias.

Capable but Careless: Do Computer-Use Agents Follow Contextual Integrity?

AGENTCIBENCH: introduces a generative evaluation harness that measures contextual-integrity failures in computer-use agents by surfacing realistic, multi-app scenarios where agents must balance task utility against privacy-sensitive information disclosure.
The framework utilizes an MCTS-based scenario-surfacing engine to generate stress tests across three failure modes: visual co-location, task-ambiguity overshare, and recipient misalignment.
Evaluation of fifteen frontier agents reveals that high task completion is a poor proxy for disclosure safety, with most agents frequently leaking personal information, though prompt-level interventions can significantly mitigate these failures.

Position: Correct Answer, Wrong Mechanism — When AI Scientists Defend General Claims Their Own Data Contradicts

CAWM (Correct Answer, Wrong Mechanism): introduces a framework for evaluating AI scientist systems by measuring task outcome, mechanism fidelity, and epistemic honesty, identifying cases where LLMs produce correct results based on physically incorrect or over-generalized reasoning.
The research demonstrates that LLMs often fail to self-apply mechanism-fidelity verification, leading to "Correct Answer, Wrong Mechanism" failures where agents defend observables with physics contradicted by their own simulation data.
The paper proposes a lightweight regime-shift verification protocol and companion recomputation as necessary gates for co-author-level trust in autonomous scientific discovery pipelines.

Decomposing Financial Market Dynamics via Mechanism Analysis in an Evolutionary Multi-Agent Simulation

Evolutionary Multi-Agent Simulation framework: introduces a modular ABM architecture that decomposes market dynamics by isolating four pluggable mechanisms to identify their specific control over emergent market properties.
The framework utilizes single-mechanism interventions to demonstrate that selection operators drive diversity, microstructure governs realism, and behavioral bias influences fragility.
The research provides a systematic decomposition of market dynamics, revealing that consensus network topology acts as an honest null with no robust effect on emergent market outcomes.

Neural Parameter Calibration for Finite-State Mean Field Games

Neural Parameter Calibration for Finite-State Mean Field Games: introduces a fully differentiable framework for learning trajectory-wise parameters of finite-state MFGs from macroscopic population data using a Neural Network φθ, an MFG Solver Φ, and Implicit Differentiation.
The framework treats the fixed-point equilibrium solver as an implicit neural network component, enabling efficient gradient computation via the adjoint method without unrolling solver iterations.
The approach is validated across synthetic and real-world datasets, demonstrating robustness to noise and the ability to perform counterfactual analysis through the forward-looking nature of the MFG formulation.

Rising From the Ashes: How Agentic AI is Unblocking Challenges in Cybersecurity

Agentic AI Framework: introduces a conceptual mapping of emergent agentic AI capabilities to long-standing cybersecurity bottlenecks, leveraging Natural language understanding, Processing large amounts of information, Cognitive stamina, Generalization and replicability, and Multi-disciplinary knowledge.
The paper evaluates 16 case studies across systems security, software security, CTI, and attack detection to demonstrate how these agentic capabilities can automate labor-intensive and knowledge-intensive security tasks.
It highlights that while agentic AI offers a path to scalable security, it necessitates rigorous verification and security-by-design to prevent the amplification of existing vulnerabilities through autonomous agents.

Understanding the (In)Security of Vibe-Coded Applications

Vulnerability Analysis Framework: introduces a multi-agent system that combines Claude Code, GitHub Copilot, OpenAI Security Best Practices Skill, Antigravity Awesome Skills, Claude Sonnet 4.6, GPT-5.3-Codex, a Validation Agent, and Human Reviewers to systematically identify and validate security vulnerabilities in vibe-coded applications.
The framework employs a 2x2 auditing design using two agent frameworks and two security skill sets to generate independent reports, which are then deduplicated and validated through automated and manual processes.
This research identifies eight recurring failure modes categorized into memory, objective, and knowledge defects that contribute to widespread security vulnerabilities in vibe-coded applications.

Managing Procedural Memory in LLM Agents: Control, Adaptation, and Evaluation

AFTER (A Benchmark for Procedural Skill Transfer in LLM Agents): introduces a benchmark and evaluation framework for measuring how procedural memory transfers across tasks, roles, and LLM backbones using AFTER, EVOLUTION, SKILL.md, Reflector, Adapter, and Trace Pool.
The framework utilizes EVOLUTION to manage the lifecycle of SKILL.md artifacts, employing a Reflector to iteratively refine procedural knowledge based on execution traces.
Experiments demonstrate that procedural memory evolved from diverse multi-model traces significantly improves cross-model generalization while revealing that role-specific specialization can hinder cross-role transfer.

A Matter of Time: Towards a General Theory of Agency

Temporally Parametrized (F, A)-systems: introduces a graded organizational theory of agency by unfolding semantically closed systems across characteristic timescales to reveal endogenous anticipatory structures.
The framework redescribes these temporally unfolded organizations as history-dependent ADBNs, where dependencies between components (A, B, C, D, E) and interface processes (X, Y, Z) are constrained by their respective timescales (ϕ, ψ, θ, α, β).
This approach provides a formal hierarchy from proto-agential chemical systems to robust agents, enabling the operational distinction between autonomy, goal-directedness, agency, and open-endedness through measurable metric profiles.

Self-Evolution for Multi-Turn Tool-Calling Agents via Divergence-Point Preference Learning

ToolGraph + DPO: introduces a framework that improves LLM tool-calling reliability by combining structural graph-based orchestration with divergence-point preference learning.
The system utilizes ToolGraph to provide structural guidance via schema-derived topology and experience-based edge weights, while DPO refines the LLM policy using preference pairs extracted from successful and failed trajectories.
By aligning training and deployment contexts and filtering preference data against action-level correctness annotations, the framework enables effective within-benchmark self-evolution for multi-turn agents.

Cognitive Digital Twins: Ethical Risks and Governance for AI Systems That Model the Mind

CDT (Cognitive Digital Twin): introduces a governance framework organized around Authority, Autonomy, Access and Control, Accountability, and Availability to address the ethical risks of AI systems that model, simulate, and act as a person's cognition.
The paper argues that CDTs require governance at the level of cognitive representation itself, as these systems can act as proxies or infrastructures through which human cognition is simulated and operationalized.
The authors propose concrete requirements for high-risk CDTs, including layered consent, purpose-binding enforcement, and traceability, to mitigate risks such as misrepresentation, epistemic authority shifts, and shadow twinning.

Safety in Self-Evolving LLM Agent Systems: Threats, Amplification, and Case Studies

MLAS (Module–Lifecycle Attack Surface) framework: introduces a systematic security analysis of self-evolving LLM agents by mapping threats across five functional modules and five evolutionary lifecycle stages.
The paper identifies seven cross-cutting amplification effects, including generational accumulation and optimizer–optimizee collapse, which transform transient attacks into persistent, self-reinforcing, and lineage-wide security threats.
Comparative case studies of OpenClaw and Hermes demonstrate that evolution-native designs significantly expand the attack surface and bypass static security scanners, necessitating evolution-aware defense architectures.

Training Open Models for Agentic Phone Use

PhoneBuddy: introduces a training recipe for agentic phone use that combines a real-app environment with a mock-app environment, PhoneWorld, to improve task completion through a shared SFT stage and mixed RL.
The framework utilizes a Qwen3.5-4B backbone and leverages PhoneWorld to provide scalable, resettable, and automatically verifiable interaction, complementing the high-fidelity but costly real-app environment.
Empirical results demonstrate that combining real-app and mock-app RL significantly outperforms individual training approaches, particularly for single-app and mini-app tasks, while highlighting persistent challenges in cross-app workflows.

UECP: Uncertainty-Enhanced Collaborative Perception

UECP (Uncertainty-Enhanced Collaborative Perception): introduces a collaborative perception framework that utilizes a physically-grounded uncertainty map to guide multi-agent feature fusion, effectively mitigating collaborative noise.
The framework employs an Uncertainty-Aware Pyramid Fusion (UAPF) module, which integrates Uncertainty-Weighted Downsampling (UWD) and Uncertainty-Guided Residual Fusion (UGRF) to enhance robustness and detection precision.
By decoupling uncertainty estimation from detection head training, UECP provides an unbiased, scenario-aware signal that improves performance across various autonomous driving benchmarks.

A Stackelberg Framework for Resource-Aware LLM Agents: Learning, Repair, and Conditional Guarantees

Stackelberg Framework for Resource-Aware LLM Agents: introduces a contextual leader-follower game to govern LLM agent resource allocation by balancing quality targets and cost incentives against executor actions.
The framework utilizes a Controller that commits to quality and budget signals, while an Executor responds with context, prompt, and tool usage actions to optimize performance under finite computational constraints.
The approach incorporates real-API calibration and action-space projection to repair learned policies, ensuring stable and safe resource governance in multi-turn LLM agent interactions.

Group-Graph Policy Optimization for Long-Horizon Agentic Reinforcement Learning

G2PO (Group-Graph Policy Optimization): introduces a reinforcement learning framework for long-horizon agentic tasks that transforms interaction trajectories into a global state-transition graph to enable fine-grained credit assignment.
The framework utilizes State Group Graph to aggregate identical observations across trajectories, significantly reducing variance in state-value estimation compared to single-trajectory methods.
G2PO incorporates Edge-Centric Advantage Estimation to prioritize critical transitions by globally standardizing Temporal Difference errors, effectively guiding LLMs toward task completion with minimal computational overhead.

Distilling Collaborative Dynamics into Latent Space for Implicit Coordination in Decentralized Multi-Agent Manipulation

CLS-DP (Collaborative Latent Space–conditioned Diffusion Policy): introduces a decentralized multi-agent framework that enables implicit coordination by distilling privileged multi-agent dynamics into a latent space during centralized training, which is then inferred by each agent from local observations at deployment.
The framework utilizes a contextualizer to encode local RGB observations and task instructions into a collaborative latent, which conditions a decentralized diffusion policy to anticipate teammate behaviors without explicit communication.
By employing a two-stage training process and discarding privileged kinematics modules at inference, CLS-DP achieves superior parameter efficiency and scalability compared to centralized baselines in multi-arm manipulation tasks.

StatABench: Dataset and Framework for Evaluating Statistical Analysis Capabilities of LLMs

StatABench: introduces a comprehensive benchmark for evaluating LLMs' statistical analysis capabilities through closed-form questions and open-ended modeling tasks.
The framework utilizes SAToolKit for tool-grounded reasoning and employs an LLM-as-Judge protocol to assess complex, open-ended statistical reports.
Experimental results reveal a significant tool-integration tax across diverse LLMs, highlighting persistent challenges in methodological decision-making and end-to-end statistical modeling.

Evo-RAD: Navigating Rare Retinal Disease Diagnosis via Self-Evolving Agentic Retrieval

Evo-RAD: introduces a self-evolving agentic retrieval framework that reformulates evidence acquisition as a Markov Decision Process to improve rare retinal disease diagnosis.
The framework utilizes a Graph Policy Network to iteratively refine a reference set through DELETE, INSERT, and TERMINATE operations, optimized via Group Relative Policy Optimization (GRPO) with a homogeneity-aware reward.
By dynamically suppressing hub-driven distractors and incorporating clinically concordant samples, the agentic approach achieves superior diagnostic performance compared to static retrieval and parameter-efficient fine-tuning methods.

Plans Don’t Persist: Why Context Management Is Load Bearing for LLM Agents

Replay Pairing: introduces a diagnostic framework to measure plan persistence in LLMs by comparing hidden-state cosine distances between trajectories with and without plan history.
The study demonstrates that LLM agents typically treat plans as context-time objects that decay rapidly within one step, rather than as persistent internal states.
The authors identify a reasoning-trace confound in reasoning models and propose strict stripping to accurately isolate plan-related signals, further validating that naive plan eviction significantly degrades agent performance.

ENVS: Environment-Native Verified Search for Long-Horizon GUI Agents

ENVS: introduces a training-time search-and-filter pipeline that leverages environment-native verification to construct balanced, high-quality supervised datasets for GUI agents.
The framework decouples trajectory discovery from policy optimization by using a Frozen Policy to explore OSWORLD Virtual Machines, followed by a Data Curator that applies global balancing to the collected trajectories.
To evaluate robustness, the paper introduces OSWORLD-NOISY, a benchmark that injects recoverable desktop interruptions to test an agent's ability to refocus, dismiss, or recover during task execution.

When Agents Commit Too Soon: Diagnosing Premature Commitment in LLM Agents

LLM Agents: introduces a diagnostic framework for detecting premature commitment, where agents settle on an interpretation early and defend it, by measuring cross-run hidden-state convergence.
The framework utilizes activation similarity at specific reasoning steps to predict trajectory consistency across multiple LLM architectures, including Llama-3.1, Qwen-2.5, and Phi-3.
The research demonstrates that while commitment signals reliably track process consistency, they are correctness-agnostic, meaning they identify settled trajectories regardless of whether the agent is right or wrong.

Intent-Governed Tool Authorization for AI Agents

IGAC (Intent-Governed Access Control): introduces a server-side authorization layer that binds AI agent tool use to the user's expressed intent through intent certificates, session policy, and consistency checks.
The framework operates as an upstream governance layer over the OpenPort effect-control substrate, ensuring that agent actions remain within the bounds of the user's current request.
IGAC utilizes manifest filtering and consistency gating to prevent overbroad tool usage and payload expansion, treating LLM-based planners as untrusted advisors rather than authoritative principals.

From Fragments to Paths: Task-Level Context Recovery for Large Industrial Codebases

DEEPDISCOVERY: introduces a two-stage Location–Inference framework that identifies high-confidence task anchors and expands over a multi-relational repository graph to recover complete task-relevant context under budget constraints.
The method utilizes metadata-first context construction to preserve structural coverage while selectively loading full-text content, thereby optimizing LLM context usage for complex software engineering tasks.
Evaluations on industrial codebases and SWE-bench Verified demonstrate that DEEPDISCOVERY consistently improves task-relevant file recovery and downstream LLM performance compared to traditional fragment-retrieval and GraphRAG-style approaches.

Agent-as-a-Router: Agentic Model Routing for Coding Tasks

ACRouter (Agentic Coding Router): introduces a framework that formalizes model routing as a Context-Action-Feedback loop to address information deficit in LLM selection for coding tasks.
The framework utilizes an Orchestrator to select models, a Verifier to provide execution-grounded feedback, and a Memory module to accumulate experience for future routing decisions.
The research introduces CodeRouterBench, a comprehensive evaluation environment with 10K tasks, demonstrating that ACRouter achieves lower cumulative regret and better generalization than static routing baselines.

DynamicMem: A Long-Horizon Memory Benchmark in Real-World Settings

DynamicMem: introduces a synthetic benchmark for evaluating long-horizon memory in LLM agents by constructing 15-month, user-consistent trajectories across 16 applications.
The framework decomposes user profiles into attributes, habits, and preferences, which evolve under causally grounded drivers to test memory retention and update capabilities.
Benchmarking reveals that while aggregate accuracy hides performance degradation, over 93% of failures originate from the memory system's retrieval rather than the answer-generation LLM.

When AUC 0.998 Is Not Enough: A Candidate Evaluation Protocol for Hidden-State Probes of Indirect Prompt Injection in Multimodal Computer-Use Agents

Candidate Evaluation Protocol for Hidden-State Probes: introduces a diagnostic framework for validating hidden-state probes in multimodal computer-use agents by pairing reported AUC metrics with specific control sets to distinguish malicious-content detection from surface-level artifacts.
The framework utilizes a Mind2Web trajectories-based replay protocol to evaluate a frozen multimodal computer-use agent, employing a linear probe for hidden-state extraction alongside C1 text-side falsifier and C2 visual overlay controls to identify shortcut-driven failure modes.
The research demonstrates that high headline AUC scores can be misleading, necessitating the use of trajectory-level cluster bootstrap and nuisance-matched controls to ensure that probes are actually detecting malicious instruction content rather than OCR-density or template-based surface statistics.

AI Scientists as Engines of Discovery: A Case for Development within Reformed Institutions

Denario: introduces a multi-agent framework for scientific discovery that utilizes a Generation agent, Critic agent, Verification agent, Controller agent, Reasoning layer, and External tools to automate the research cycle.
The architecture enables an internal dialectic among specialized agents to traverse model parameter spaces and accelerate scientific discovery beyond human capacity.
The paper argues that institutions must be redesigned to support AI scientists through improved verification, accountability, interpretability, and dual-use safety protocols.

RaMem: Contextual Reinstatement for Long-term Agentic Memory

RaMem (Contextual Reinstatement for Agentic Memory): introduces a framework that mitigates context collapse by anchoring memory fragments to episodic conditions and performing validity-aware retrieval.
The framework utilizes LLMClient, EmbeddingModel, VectorStore, MemoryBuilder, HybridRetriever, and AnswerGenerator to transform retrieved fragments into contextually verifiable evidence.
RaMem improves long-term memory performance by prioritizing context-compatible memories while retaining content-relevant candidates as fallback evidence during synthesis.

RLM-Cascade: Response-Level Speculative Decoding for Cost-Efficient LLM API Serving

RLM-Cascade: introduces a response-level speculative decoding proxy system that reduces LLM API costs by routing requests between a fast draft model and a capable verify model.
The system utilizes a rule-based router to classify agentic turns, enabling the SKIPPED path for simple requests and a draft-then-verify pipeline for complex tasks.
By treating the full response as the unit of speculation, the framework operates over standard HTTP APIs without requiring access to internal model logits or shared vocabularies.

Active Inference as the Test-Time Scaling Law for Physical AI Agents

Active Inference as the Test-Time Scaling Law for Physical AI Agents: introduces a novel test-time scaling law for physical AI agents grounded in active inference that enables generalization in unforeseen scenarios by dynamically updating policies through surprise-minimizing reasoning.
The framework utilizes a world model at the network edge to detect prediction errors and trigger a transition from habitual policy execution to deliberative reasoning, effectively scaling the agent's policy at test time.
By modeling the resolution of prediction errors as a variational inference problem, the approach enables physical AI agents to continuously learn and adapt to non-stationary environments without requiring retraining.

Does the Same Token Mean the Same State? MoE Routing as Signal for Reasoning Control

RAD (Routing Agreement Decoding): introduces a method for selecting high-quality LLM rollouts by analyzing sparse MoE routing states as a white-box agreement signal, utilizing MoE Router, Anchor-Conditioned Routing, Weighted-Jaccard K-NN, Consensus Matrix, Routing Density Selector, and DeepConf Confidence Signal.
The framework identifies dense routing neighborhoods that align with answer basins, enabling effective selection in open-ended or lexically diverse tasks where traditional string-based voting fails.
RAD operates as a consensus-based selector that aggregates routing agreement rather than verifying truth, providing competitive performance to majority voting in well-posed settings and superior results in code generation and agentic tasks.

Breaking the Evaluation Paradox: Evaluating High-Entropy Search with Computationally Irreducible Constraints

VERITAS (Verifiable Traversal Assessment for Search): introduces a benchmark that replaces semantic filters with computationally irreducible cryptographic hash constraints to force LLMs into genuine exhaustive search.
The framework utilizes Search, Visit, Exec Python, and Answer components to evaluate an agent's ability to systematically traverse large, unstructured search spaces without relying on search engine shortcuts.
By requiring agents to find items matching specific hash values, VERITAS provides an automatically verifiable, scalable, and difficulty-tunable evaluation paradigm for high-entropy search tasks.

Noise Is Signal: Density-Based Outliers as Leading Indicators of Occupational Emergence in Labor Market Text

EOS: introduces a framework for detecting emerging occupations by analyzing the semantic coherence of noise-class postings in high-dimensional embedding spaces.
The framework utilizes INSTRUCTOR-xl, UMAP, and HDBSCAN to identify pre-cluster noise groups, which are then evaluated using the EOS metric to predict future occupational consolidation.
By demonstrating that density-based outlier scores are uninformative for emergence, the paper establishes that semantic coherence within the noise class serves as a reliable leading indicator for new job roles.

Cooperative-ORCA*: Real-Time Proactive Deadlock Avoidance for Continuous-Space Multi-Agent Navigation

C-ORCA* (Cooperative Optimal Reciprocal Collision Avoidance): introduces a continuous-space multi-agent navigation framework that integrates global guidance paths with local collision avoidance to proactively resolve deadlocks using MAPFPlanner, CorridorDetector, DependencyBuilder, StringPulling, WaypointManager, DriftModeController, and ORCAVelocitySolver.
The framework utilizes pre-computed guidance paths and dynamic dependency detection to switch agents between standard and drift modes, effectively preventing congestion in narrow corridors.
By proactively managing agent interactions through waypoint updates and adaptive velocity control, the approach significantly improves success rates and reduces flowtime compared to reactive baseline methods.

HERCULES: An Open-Source Simulation Framework for Heterogeneous Multi-Robot SLAM, Collaborative Perception, and Exploration

HERCULES: introduces an open-source, Unreal Engine 5-based simulation framework designed for heterogeneous multi-robot autonomy, featuring a unified navigation stack, synchronized data-collection, and support for concurrent UAV-UGV operations.
The framework resolves architectural conflicts in prior simulators to enable concurrent multi-robot simulation, providing specialized controllers, physics-based thermal and night-vision sensors, and dynamic environmental processes for realistic testing.
HERCULES facilitates research in collaborative SLAM, cooperative 3D object detection, and closed-loop multi-robot exploration by providing a scalable, photorealistic testbed with ready-to-run benchmarks and sim-to-real transfer capabilities.

GRADE: Graph Representation of LLM Agent Dependency and Execution

GRADE: introduces a unified two-layer graph representation for LLM agent runs that separates observed execution flow from graded state-dependency reliance to enable failure diagnosis.
The framework utilizes an attachment model to grade dependency edges as observed, declared, or inferred, addressing the blind spot where standard traces fail to record state reliance.
By pricing the dependency layer's marginal lift over the free execution layer, GRADE identifies that dependency structure provides transferable failure-prediction signals that generic graph networks often misread due to structural degeneracy.

GroundEval: A Deterministic Replacement for LLM-as-Judge in Stateful Agent Evaluation

GroundEval: introduces a judge-free framework for evaluating LLM agents by verifying their evidence paths against deterministic state contracts rather than relying on LLM-as-judge plausibility.
The framework utilizes a machine-readable contract comprising an event log, artifact corpus, access policy, and evaluation configuration to score agent performance across Perspective, Counterfactual, and Silence tracks.
GroundEval provides structured diagnostics and a compliance-adjusted scoring model to detect state-invalid correctness, such as temporal leakage, permission violations, and ungrounded causal claims.

Closed-loop Auto Research for Molecular Property Prediction: Discovering and Certifying Generalizable Improvements

Closed-loop Auto Research: introduces a framework where LLM-agents iteratively propose and execute interventions across feature, model, and data axes to improve molecular property prediction pipelines.
The framework utilizes a file-level ablation lock to isolate research axes and a held-out certification protocol to distinguish genuine transferable discoveries from validation-selected artifacts.
The system incorporates a leakage-safe filter to audit external data acquisition, ensuring that improvements are not derived from test set contamination or distribution shifts.

Safe and Generalizable Hierarchical Multi-Agent RL via Constraint Manifold Control

HMM (Hierarchical Manifold Multi-Agent PPO): introduces a hierarchical MARL framework that decouples high-level cooperative planning from low-level safety enforcement using a constraint manifold.
The framework utilizes a high-level policy for multi-agent coordination and a low-level constraint manifold safe controller to project nominal actions onto a safe tangent space, ensuring hard safety constraints without per-timestep quadratic programming.
By offloading safety to a fixed low-level controller, the approach enables stable, stationary learning for the high-level policy while providing formal safety guarantees and strong generalization across varying agent and obstacle counts.

ChartWalker: Benchmarking the Cross-Chart RAG Task with Hierarchical Knowledge Graphs

ChartWalker: introduces a framework for constructing challenging cross-chart RAG tasks by organizing chart entities into a Hierarchical Knowledge Graph and synthesizing reasoning paths via a Structure-aware Sampling Algorithm.
The framework includes ChartWalker-Bench, a benchmark with 564 multi-hop QA instances, and ChartWalker-Agent, which utilizes a VLM-based search agent to navigate the knowledge graph for iterative evidence acquisition.
Experimental results demonstrate that graph-based retrieval and agentic reasoning significantly improve performance on complex multi-hop queries compared to static RAG pipelines.

EMAgnet: Parameter-Space EMA Regularization for Policy Gradient Self-Play in Large Games

EMAgnet: introduces a parameter-space exponential moving average regularization method for PPO self-play that adapts to the agent's evolving strategy by maintaining a moving target of network weights.
The framework utilizes a Policy Network, Magnet Parameters, and an EMA Update to effectively regularize toward viable actions while ignoring strictly dominated strategies in complex game environments.
By incorporating a KL Divergence Loss term, the approach enables stable convergence in two-player zero-sum games with large strategy spaces where uniform regularization typically fails.

Learning to Trigger: Reinforcement Learning at the Large Hadron Collider

GFPO: introduces a self-driving trigger framework that adapts selection thresholds online using DQN, GRPO, GFPO-F, and GFPO-FR to maintain stable background rates while maximizing signal efficiency.
The framework utilizes a Recurrent Encoder to process event sequences and a Safety Shield to enforce operational constraints, ensuring robust performance under non-stationary physical conditions.
GFPO-F and GFPO-FR address the zero-feasibility failure mode of standard policy optimization by enforcing rate constraints before advantage normalization, demonstrating superior generalization to real collision data.

Critique of Agent Model

GIC (Goal-Identity-Configurator): introduces a general-purpose agent architecture that internalizes agency by combining a Belief Encoder, Goal Decomposer, Identity Evolver, Configurator, Simulative Planner, and Actor, all operating with a separately trained World Model and Critic.
The framework distinguishes between agentic systems, which rely on external scaffolding, and agentive systems, which derive capabilities endogenously through internalized modules for planning, self-regulation, and learning.
GIC enables persistent, self-directed operation by allowing the agent to autonomously manage its deliberative mode, goal decomposition, and identity evolution, thereby improving auditability and safety compared to monolithic LLM-based agent designs.

Forget Without Compromise: Nexus Sampling for Streaming KV-Cache Eviction Under Fixed Budgets

Nexus Sampling: introduces a training-free KV cache eviction method that replaces deterministic top-K selection with Nexus scoring and weighted reservoir selection to prevent monotone marginal erosion.
The framework utilizes an iterative walk to identify bridge tokens that anchor strongly-connected clusters, ensuring these are preserved alongside marginal tokens via weighted reservoir sampling.
By treating KV cache eviction as a streaming problem, Nexus Sampling maintains long-run token survival through a product-over-steps probability, significantly outperforming existing methods on retrieval-heavy long-context tasks.

When Retrieval Metrics Mislead: Measuring Policy Signal in Long-Horizon Tool-Use Agents

SSDG (Structured State Decision Gate): introduces a framework for evaluating policy-conditioned tool-use agents by comparing structured decision-state representations against raw trajectory inputs.
The framework utilizes a generator to distill dialogue, tool outputs, and policy assertions into a compact structured state, which significantly improves the macro-F1 performance of LLM classifiers compared to raw text.
The study demonstrates that exact-match retrieval recall is a pessimistic proxy for downstream policy utility, as non-matching retrieved clauses often contain sufficient decision-relevant information for effective classification.

RIFT-Bench: Dynamic Red-teaming For Agentic AI Systems

RIFT-Bench: introduces a representation-driven methodology for dynamic red-teaming of agentic AI systems, utilizing NodeSpec to enable transferable adversarial evaluation across heterogeneous architectures.
The framework operates through an automated Discovery phase to extract system structure and a Scanning phase to deploy adaptive adversarial probes, providing a scalable foundation for security assessment.
RIFT-Bench includes a benchmark of 45 diverse agentic systems and 105 adversarial probes, demonstrating effective vulnerability assessment and mitigation strategy evaluation across various agentic implementations.

Topological Online Learning for Displacement-based Formation Control

TOLD (Topological Online Learning for Displacement-based formation control): introduces a real-time edge-level adaptation framework that optimizes interaction topology weights to minimize formation distortion, utilizing Formation Sensing, Online Gradient Flow (OGF), Online Exponential Gradient Flow (OExpGF), Formation Control Fusion, and Robot Execution.
The framework employs OGF for unconstrained weight updates to achieve superior formation accuracy and OExpGF for non-negative convex weight updates to ensure bounded, predictable dynamics.
TOLD functions as a modular topological routing overlay that integrates with physical-layer robust controllers to enhance multi-robot formation robustness against environmental disturbances and sensor noise.

REALM: A Unified Red-Teaming Benchmark for Physical-World VLMs

REALM: introduces a unified red-teaming benchmark for physical-world VLMs that integrates 12 attack methods, 3 model-agnostic defenses, and 13 victim VLMs under a standardized black-box protocol.
The framework utilizes an agentic target-generation pipeline to construct scenario-specific, physically grounded adversarial objectives that enable fair comparison across diverse attack families.
Evaluation results demonstrate that text-channel injection attacks induce the most frequent failures, while model scale alone does not guarantee adversarial robustness in physical-world tasks.

Complex Autonomous UAV Task Execution and Decision-Making With s(CASP)

VECSR-A (Virtually-Embodied Common Sense Reasoner for Autonomous UAVs): introduces a symbolic state-centered agent architecture that utilizes s(CASP) for constraint-based commonsense reasoning to enable explainable and adaptive UAV task execution in high-fidelity simulated environments.
The framework integrates a Simulation Environment, s(CASP) Knowledge Base, VECSR-A Orchestrator, and s(CASP) Goal-Directed Server to perform hierarchical task decomposition and real-time decision-making without requiring model retraining.
By leveraging goal-directed answer set programming, the system provides verifiable justification trees for autonomous actions, ensuring transparency and reliability in safety-critical mission scenarios.

From Task-Guided Conversational Graphs to Goal-Oriented Dialogue Runtimes

GODR (Goal-Oriented Dialogue Runtime): introduces a framework-neutral architectural layer that manages conversational goal lifecycles, resumption contracts, and dependencies as first-class runtime objects above existing execution substrates.
The framework separates objective continuity from execution continuity by delegating bounded tasks to LLM-based agents and tools while maintaining explicit goal state, policy, and auditability.
GODR addresses the Multi-Objective Interruptible Dialogue Problem by providing a taxonomy of goal complexity and a formal operational model for managing suspended, resumed, and invalidated user objectives.

GUI vs. CLI: Execution Bottlenecks in Screen-Only and Skill-Mediated Computer-Use Agents

GUI vs. CLI: introduces a matched execution-layer benchmark to isolate interaction modality effects by holding goals, initial states, and verifiers constant across GUI agents and skill-mediated CLI agents.
The study identifies that GUI agents are primarily bottlenecked by visual grounding and long workflow execution, while CLI agents are limited by skill coverage gaps and implicit-default reconstruction.
Diagnostic experiments reveal that verifier-guided skill patching significantly improves CLI performance, highlighting skill construction and validation as the central scaling challenge for programmatic computer-use agents.

Cryptographic certificates of validity for trustworthy AI

Cryptographic certificates of validity for trustworthy AI: introduces a mechanism to certify agentic AI actions by compiling formal correctness predicates into polynomial constraints verified via succinct cryptographic proofs.
The framework enables untrusted agents to provide independently checkable evidence of policy compliance, bridging the gap between high-level formal specifications and cryptographic proof back ends.
By utilizing polynomial arithmetisation, the approach allows for the verification of complex agent behaviors, including recursive computations, without requiring the verifier to trust the agent or inspect private witness data.

Emergent Relational Order in LLM Agent Societies: From Collective Affect to Authority Stratification

CAREB-MAS: introduces a multi-agent simulation framework that models the emergence of social structures from micro-level cognitive mechanisms grounded in Affect Control Theory, Social Identity Theory, and Durkheimian collective affect.
The framework utilizes an augmented BDI architecture that includes Empathy Core, Ethical Resonator, and A-BDI Decision Module to simulate how agents maintain egocentric identities and relational order without explicit cultural rules.
Experimental results demonstrate that the framework reproduces core social phenomena such as stable labor specialization, guanxi-based economic ethics, and authority stratification, which vary systematically based on production structure.

Engineering Reliable Autonomous Systems: Challenges and Solutions

ERAS: introduces a workshop report outlining challenges and pathways for engineering reliable autonomous systems through integrated verification and architectural design.
The framework utilizes assumption/guarantee contracts to link heterogeneous components, including vision-, planning-, and hardware-agents, enabling modular verification.
The report provides a research roadmap and case study analysis to bridge the gap between academic verification techniques and real-world autonomous system deployment.

ESAA-Conversational: An Event-Sourced Memory Layer for Continuity, Handoff, and Curation Across Heterogeneous LLM Coding Agents

ESAA-Conversational: introduces an event-sourced memory layer that captures conversational turns from heterogeneous LLMs into a shared, append-only log to ensure continuity and handoff without requiring a common runtime.
The framework utilizes a CLI to perform inverted ingestion, where native agent logs are normalized into events, and read models are deterministically projected to provide agents with relevant context.
By separating mechanical capture from agent-driven curation, the system enables collaborative multi-agent workflows while maintaining operational auditability and privacy through a greenfield distribution model.

21st June 2026

Habituation at the Gate: Rising Approval and Declining Scrutiny in Human Review of AI Agent Code

AIDev: introduces a longitudinal analysis of human code review behavior, demonstrating that reviewers systematically increase approval rates for AI-generated pull requests as they accumulate experience.
The study reveals that rising approval rates are accompanied by a significant decline in inline comment effort and increased review latency, suggesting reflexive habituation under growing workloads.
The research provides evidence that this trend is agent-specific and experience-driven, rather than a result of improved code quality or general reviewer leniency, raising concerns for human oversight in software development.

Beyond Simpson’s Paradox: A Cascade of Confounders in AI Agent Pull-Request Co-Authorship

Collaboration-level framework: introduces a four-level taxonomy of human involvement in LLM-based agent pull requests, ranging from L0: Fully autonomous to L3: Human-both.
The study demonstrates that aggregate negative associations between human co-authorship and pull request merge rates are a manifestation of Simpson’s Paradox driven by agent composition and structural confounders.
Empirical analysis reveals that once repository selection and pull request structure are controlled, the apparent causal benefit of human co-authorship in LLM-generated code dissolves.

Libretto: Giving LLM Agents a Sense of Musical Structure

Libretto: introduces an agent-facing framework for symbolic music generation and revision that utilizes a Grammar, a Structural Axis System, an Agent Loop, Knowledge Bases, and Application-Specific Task Setups.
The framework represents music as a measurable, editable object by mapping symbolic sequences into a 29-axis statistical fingerprint, enabling LLMs to diagnose and refine compositions through iterative feedback.
Libretto supports diverse musical tasks including gap filling, full-piece generation, gradual style morphing, and educational drill creation without requiring specialized training for each application.

VERIPORT: Automated and Verified Patch Backporting at Scale

VERIPORT: introduces an end-to-end agentic system that automates the backporting of security patches across affected software versions by generating and verifying evidence through AUTORESEARCH, AUTOPOC, AUTOTESTER, and AUTOPATCH.
The framework utilizes a multi-stage pipeline where AUTOPOC and AUTOTESTER build vulnerability and functionality oracles to ensure that backported patches are both effective and non-breaking.
By decomposing the backporting process into bounded, independently verified stages, VERIPORT mitigates LLM-based failure modes and achieves high reliability in patch adaptation across diverse software versions.

Black-Box Forensics for Conversational LLM Agents

Black-Box Forensics for Conversational LLM Agents: introduces a framework for identifying base models and system prompts of conversational LLMs through active elicitation and non-adversarial dialogue.
The framework utilizes a Detective Agent to steer conversations, enabling the extraction of behavioral signatures that are processed by Cross-Encoder and Bi-Encoder components to perform zero-shot fingerprinting of unseen system prompts.
The approach achieves high accuracy in attributing base models and fingerprinting system prompts without requiring access to model weights, output logits, or prior training data from the target agent.

VISTA Architect: A graph database-oriented health AI system demonstrated in multidisciplinary tumor boards

VISTA Architect: introduces a database-oriented AI architecture that integrates LLMs with longitudinal EHRs by transforming clinical documentation into a persistent, provenance-linked knowledge graph, utilizing MEDS Graph, TOA Graph, Agentic AI Bridge, User Interface, and Provenance Links.
The system employs a two-tiered graph structure where the MEDS Graph preserves granular EHR data and the TOA Graph synthesizes this into a queryable, temporally coherent clinical narrative.
By precomputing clinical synthesis at ingestion, the architecture enables deterministic graph traversal for downstream applications, significantly reducing computational overhead and latency compared to traditional RAG approaches.

Integrated cloud-based architecture for robot-robot and human-robot collaboration using ROS 2 – MQTT in Mediterranean Greenhouses

GMaaS (Greenhouse Models as a Service): introduces a cloud-based hybrid architecture that establishes a bidirectional communication bridge between ROS 2 edge-computing platforms and the iVeg Decision Support System using MQTT and FIWARE to enable real-time multi-robot and human-robot collaboration.
The framework utilizes YOLOx for real-time edge-based detection of farmers and robots, converting visual data into lightweight geometric metadata to maintain fleet-wide situational awareness under severe communication constraints.
By integrating ROS 2 with MQTT and FIWARE, the architecture provides a scalable, decentralized solution for managing complex robotic missions in occluded greenhouse environments while ensuring low-latency safety overrides and human-in-the-loop oversight.

RigorBench: Benchmarking Engineering Process Discipline in Autonomous AI Coding Agents

RigorBench: introduces a process-oriented benchmarking framework that evaluates AI coding agents based on engineering discipline rather than just final outcome correctness.
The framework utilizes a trajectory-based scoring pipeline that incorporates Trajectory Parser, Signal Extractor, Pillar Scorer, LLM-as-judge Panel, and an Instrumented Docker Environment to measure five pillars of software engineering.
Experimental results demonstrate that structured process discipline significantly improves both process quality and downstream outcome correctness in LLMs.

AgentLens: Interpretable Safety Steering via Mechanistic Subspaces for Multi-Turn Coding Agent

AgentLens: introduces a white-box defense framework that performs runtime safety detection and representation-level mitigation for multi-turn coding agents by leveraging Linear Probe and Mitigation Stage.
The framework utilizes a Safety Detection Stage to identify harmful execution states from step-level hidden representations and an LLM Controller to adaptively search for steering strengths that suppress harmful actions.
AgentLens employs a Steering Engine to apply representation-level interventions at specific layers, guided by the MAS Benchmark to ensure robust safety across multi-turn coding agent trajectories.

RAVEN: Agentic RAG for Automated Vulnerability Repair

RAVEN: introduces an agentic RAG-based framework that integrates multi-faceted historical fix retrieval, repository-level context dependency analysis, and iterative patch refinement to autonomously repair real-world software vulnerabilities.
The framework utilizes open-source LLMs, including Gemma-4-26B and Nemotron-3-30B, to perform locally deployable, cost-effective, and scalable vulnerability repair across diverse programming languages and CWE categories.
RAVEN employs a dedicated Curator Agent for repository exploration and an iterative feedback loop between the Patch Generator and Patch Reviewer to ensure high-quality, semantically meaningful, and secure code patches.

SkillAudit: From Fixed-Suite Benchmarking to Skill-Centered Assessment

SkillAudit: introduces an end-to-end framework for skill-centered assessment that automatically generates multi-dimensional evaluation reports for arbitrary agent skills by leveraging Skill Collection, Scheme Generation, Task Construction, Sandboxed Execution, Automated Evaluation, and a Browser Extension.
The framework employs a baseline comparison principle to isolate the marginal utility and efficiency/cost gains of a skill from the backbone LLM's intrinsic capabilities.
To assess safety, SkillAudit utilizes a two-stage detection paradigm combining static semantic analysis of skill packages with dynamic runtime verification to determine both the existence and exploitability of potential risks.

Harnessing Agents for Autonomous Research and Human-in-the-Loop Refinement

PAPERCLAW: introduces a harnessed multi-agent system that automates the entire research lifecycle from domain curation to venue-compliant paper generation using a stoppable iterative hypothesis map.
The system utilizes an in-cycle research assistant and full-lifecycle memory to maintain project context, enabling autonomous execution and human-in-the-loop refinement across web, desktop, and command-line interfaces.
PAPERCLAW enforces scientific discipline through structural constraints, including pre-registered hypotheses, deterministic citation validation, and hardware-aware feasibility gating to ensure trustworthy autonomous research.

Sol Video Inference Engine: Agent-Native Full-Stack Acceleration Framework for Efficient Video Generation

Sol Video Inference Engine: introduces an agent-native framework that automates instance-specific acceleration for video diffusion models by orchestrating Parallel Skill Agents, an Agent Integrator, and a Human Validator.
The framework optimizes inference through a full-stack approach, integrating Diffusion Cache, Token Pruning, Sparse Attention, Kernel Fusion, and Quantization to achieve significant speedups.
By treating acceleration as an instance-specific tuning problem, the system bypasses manual engineering, delivering over 2× end-to-end speedup across diverse models like Cosmos3-Super, LTX-2.3, and SANA-Video.

Stationary Robust Mean-Field Games under Model Mismatches

Robust Mean-Field Games (Robust MFG): introduces a framework for infinite-horizon stationary distributionally robust mean-field games that incorporates model uncertainty directly into population-coupled dynamics.
The framework utilizes a robust dynamic programming principle with a contractive Bellman operator to prove the existence of a stationary robust mean-field equilibrium via fixed-point arguments.
The paper provides the first convergent algorithm for robust MFGs and establishes non-asymptotic error bounds for approximating finite-player robust games as the population size increases.

MacAgentBench: Benchmarking AI Agents on Real-World macOS Desktop

MacAgentBench: introduces a comprehensive macOS desktop benchmark comprising 676 tasks across 25 applications, utilizing a Docker-QEMU infrastructure, deterministic rule-based evaluation, and fine-grained multi-checkpoint scoring.
The benchmark supports diverse CUA paradigms, including pure GUI agents, hybrid frameworks, and agent harnesses, with nearly 60% of tasks involving both GUI and CLI interaction.
Experiments reveal that framework design and skill augmentation significantly impact agent performance, with fine-grained evaluation exposing capability imbalances that binary pass/fail metrics fail to capture.

Governance Decay: How Context Compaction Silently Erases Safety Constraints in Long-Horizon LLM Agents

Governance Decay: introduces a failure mode where LLM agents lose in-context safety constraints during routine context compaction, leading to unauthorized tool-call violations.
The paper presents the ConstraintRot benchmark to quantify how compaction-induced deletion of soft organizational policies significantly increases agent violation rates compared to hard safety norms.
The authors propose Constraint Pinning as a training-free defense that protects governance constraints from lossy compaction by quarantining and re-injecting them into the agent's context.

Imagine to Ensure Safety in Hierarchical Reinforcement Learning

ITES (Imagine To Ensure Safety in HRL): introduces a hierarchical reinforcement learning framework that integrates a world model and a cost model to enforce safety constraints during both subgoal generation and execution.
The framework utilizes a high-level policy to generate safe subgoals and a low-level policy that leverages imagined rollouts within a learned world model to avoid unsafe behaviors.
By combining hierarchical decomposition with model-based safety verification, the approach effectively addresses long-horizon tasks while maintaining strict adherence to safety constraints.

Lingering Authority: Revocable Resource-and-Effect Capabilities for Coding Agents

PORTICO: introduces a reference monitor that enforces capability lifetime for coding agents by compiling task contracts into initial envelopes, grant rules, and closure rules to prevent lingering authority.
The framework utilizes a request-grant-invoke lifecycle where the planner requests authority, the monitor mints epoch-bound handles, and closure rules remove these handles from the interface once the justification ends.
PORTICO ensures that only task-justified capabilities are exposed to the LLM planner, effectively mitigating stale-handle reuse and unauthorized side effects in coding agent environments.

WebCQ: Cooperative Multi-Agent Deep Reinforcement Learning for Scalable Web GUI Testing

WebCQ: introduces a cooperative multi-agent deep reinforcement learning approach for scalable web GUI testing, utilizing DQN-based Decentralized Execution, QTRAN-based Centralized Training, a Lightweight Synchronization Mechanism, a Hybrid Reward Function, State Vector, Action Vector, Q-network, Global Buffer, and Local Buffer.
The framework employs a centralized training and decentralized execution paradigm to coordinate multiple agents, effectively managing large-scale web state spaces through deep reinforcement learning.
WebCQ significantly improves exploration efficiency and failure detection by replacing tabular reinforcement learning with deep Q-networks and advanced multi-agent coordination.

Grounded Scaling: Why Agentic AI Needs Deterministic Environments

Grounded Scaling: introduces a framework that identifies environmental determinism as a critical, under-discussed binding axis for AGI-to-ASI progress, addressing bottlenecks through Data Wall, Abstraction Barrier, Embodied Bottleneck, Multi-Agent Trust, Supply Certainty Index (SCI), Determinism Maturity Model (DMM), Data Flywheel, A2A Flywheel, Verifier Service, Skill Registry, A2A Router, and Determinism Telemetry Plane.
The paper formalizes the Determinism–Efficiency Bound and Verifier–Goodharting Floor to demonstrate how stochastic environments exponentially degrade long-chain agent performance.
It proposes a five-level Determinism Maturity Model and a reference architecture to transition agentic environments from human-optimized stochastic interfaces to deterministic, verifiable substrates.

VADAOrchestra: Neurosymbolic Orchestration of Adaptive Reasoning Workflows

VADAOrchestra: introduces a neurosymbolic framework that integrates an LLM-based Orchestrator for dynamic planning with a VADALOG Engine for verifiable symbolic reasoning.
The framework utilizes a Dependency Graph to enforce domain-specific constraints and a Logical Trace to ensure auditability and reproducibility of the reasoning process.
By decoupling high-level orchestration from symbolic inference via MCP Tools, the architecture addresses scalability limitations and improves faithfulness compared to standard agentic systems.

Governed AI-Assisted Engineering: Graduated Human Oversight for Agentic Code Generation in Regulated Domains

GAIE: introduces a three-tier graduated human oversight model that routes agentic code generation tasks through OCM, Supervisor Agent, Collaborator Agents, Human Interaction Layer, Evidence Capture Layer, Monitoring Subsystem, and Immutable Store to ensure regulatory compliance.
The framework utilizes a deterministic OCM to classify tasks by regulatory impact, customer proximity, reversibility, and data sensitivity, assigning them to appropriate oversight tiers ranging from human-in-the-loop to fully automated monitoring.
GAIE preserves agentic coding velocity by applying proportionate oversight, ensuring that high-risk strategic functions receive rigorous human review while internal tasks benefit from automated compliance evidence generation.

A Differentiable Atari VCS: A Complex, Fully Known Ground Truth for Explainable AI

Differentiable Atari VCS: introduces a fully differentiable, bit-exact re-implementation of the Atari 2600 architecture, comprising 6507 CPU, TIA, RIOT, and cartridge ROM, to provide a verifiable ground truth for XAI methods.
The framework utilizes a dual-mode execution architecture, featuring a hard-mode emulator for bit-exact forward passes and a soft-mode emulator that employs a straight-through estimator to generate surrogate gradients for explainability analysis.
By treating ROM as a weight tensor and RAM as a differentiable tape, the system enables gradient-based attribution on a complex, fully specified computer architecture, allowing researchers to validate XAI techniques against known internal mechanisms.

SVGym (SciVerseGym): An Environment for Reinforcement Learning and Bayesian Optimization in Crystal Discovery

SciVerseGym: introduces a Gymnasium-compatible environment for closed-loop crystal discovery that decouples search algorithms from materials-specific infrastructure using a standardized transition protocol.
The framework supports diverse search strategies, including RL, Bayesian optimization, evolutionary search, and language-agent workflows, by providing a unified interface for structured crystal edits and physically informed feedback.
By utilizing a bounded action schema and modular evaluation backends, SciVerseGym enables reproducible benchmarking and rapid prototyping of materials discovery strategies under consistent physical assumptions.

Curvature-Adaptive Consistency Flow Matching: Autonomous Trajectory Optimization via Reinforcement Learning

CACFM: introduces a reinforcement learning-based framework that reformulates consistency distillation as a dynamic decision process to optimize training trajectories.
The framework utilizes an RL agent to identify and prioritize high-curvature trajectory segments, replacing static sampling heuristics with an emergent curriculum.
By integrating a hybrid objective of structural consistency, distribution matching, and adversarial losses, the model achieves state-of-the-art performance in few-step image generation.

PlanBench-XL: Evaluating Long-Horizon Planning of LLM Tool-Use Agents in Large-Scale Tool Ecosystems

PlanBench-XL: introduces an interactive benchmark for evaluating long-horizon planning of LLM agents in large-scale, retrieval-mediated, and unreliable tool ecosystems.
The framework utilizes a scalable generation pipeline to create complex retail tasks, incorporating bi-directional exploration and retrieval-time blocking to stress-test agent adaptation and re-planning capabilities.
Comprehensive evaluation of frontier LLMs reveals that agents struggle with massive-tool planning, particularly when faced with silent tool failures or the need for longer recovery paths.

MetaPS: Adaptive Programmatic Strategy Selection for Market Agents

MetaPS: introduces a simulation-guided framework for adaptive programmatic strategy selection that decouples high-level strategy choice from low-level action execution.
The framework utilizes a MetaPS Router to select from a library of Executable Strategy Modules based on market state, with supervision derived from counterfactual rollouts in a Market Simulator/Backtester.
By delegating final action generation to a Deterministic Execution Layer, MetaPS improves interpretability and performance compared to direct LLM-based action prediction.

Select-to-Act: Hierarchical Reinforcement Learning via Adaptive Language Guidance

HRLLI: introduces a hierarchical reinforcement learning framework that decomposes instruction usage into a high-level selector and a low-level executor to adaptively ground language instructions into stage-specific decisions.
The framework utilizes an Instruction Encoder, State Encoder, High-Level Instruction Policy (Selector), Low-Level Action Policy (Executor), Reward Model, High-Level Buffer, and Low-Level Buffer to optimize instruction selection and action execution simultaneously.
By explicitly modeling instruction selection as a discrete decision process, the approach improves sample efficiency and interpretability in instruction-heavy reinforcement learning environments.

Hypothesis-Driven Skill Optimization for LLM Agents

HDSO (Hypothesis-Driven Skill Optimization): introduces a train-free framework that decouples a frozen curator LLM from a frozen executor LLM to iteratively optimize agent skills through a hypothesis-driven lifecycle.
The framework utilizes paired control/treatment executions to validate candidate skills, ensuring only supported procedural knowledge is consolidated into an approved repository.
HDSO maintains an auditable skill lifecycle by recording rejected hypotheses and validation evidence, providing robustness against noisy feedback and enabling cross-model skill transfer.

BabelJudge: Measuring LLM-as-a-Judge Reliability Across Languages and Agent Trajectories

BabelJudge: introduces a benchmark and reliability audit framework that measures LLM-as-a-judge failure modes using gold-labelling-by-degradation to eliminate human annotation requirements.
The framework utilizes a Multilingual Corpus, Perturbation Engine, and Gold-Labeled Item components to systematically probe for position bias, verbosity bias, order inconsistency, and cross-lingual degradation.
BabelJudge extends to agentic settings by incorporating trajectory-level perturbations and specific metrics to evaluate tool-calling reliability and hallucination blindness in LLMs.

20th June 2026

REVELIO: Cost-Efficient Agentic Memory Safety Vulnerability Detection For Repository-Scale Codebases

REVELIO: introduces an end-to-end agentic framework that decomposes memory safety vulnerability detection into a high-recall hypothesis generation stage using inexpensive LLMs and a high-precision confirmation stage using stronger LLMs and deterministic sanitizers.
The framework utilizes a funnel-style pipeline that includes hypothesis generation-, triage-, PoV construction- and reporting-agents to systematically identify and verify vulnerabilities while maintaining zero false positives.
By enforcing a programmatic workflow that separates speculative reasoning from executable confirmation, REVELIO achieves scalable, cost-efficient, and trustworthy vulnerability discovery in large C/C++ codebases.

Quantifying Theoretical AI Alignment Guarantees: Receiver-Utility Bounds in Bayesian Persuasion

BPM (Bayesian Persuasion Model): introduces a theoretical framework to quantify receiver-utility bounds in scenarios where a misaligned AI sender influences a human receiver's decisions through strategic signaling.
The framework utilizes a bit-string model to isolate the mechanism of incentive-driven information transfer, establishing a universal 3/2 upper bound on the ratio of sender-optimal receiver utility to prior-only utility.
The research provides analytical proofs for product and near-product priors while demonstrating via a six-bit counterexample that no universal 5/4 bound exists for receiver utility.

Lexical Consensus: Grounded Word Learning and Shared Meaning in Artificial Agents

Lexical Consensus: introduces an experimental framework for studying grounded word learning over a structured perceptual substrate using frozen DINOv2 visual embeddings and interpretable lexical learners.
The framework evaluates whether artificial agents can acquire, stabilize, and use novel lexical mappings bidirectionally, demonstrating that acquisition is constrained by a perceptual-coherence gradient.
Multi-agent experiments reveal that while consensus refines lexical agreement, shared perceptual geometry remains the dominant stabilizing force, with minimal representational reorganization.

When Is Emergent Consensus Real? A Measured Coupling Gain and a Validity Diagnostic for LLM Agent Societies

LLM Agent Societies Framework: introduces a measurement protocol using coupling gain γ and an authenticity diagnostic to distinguish genuine social dynamics from model-prior artifacts in LLM agent interactions.
The framework utilizes counterfactual perturbation to measure per-agent susceptibility, revealing that pairwise coupling often mis-estimates multi-agent outcomes compared to modality-matched group pull.
By applying classical opinion dynamics like Friedkin–Johnsen and signed-Laplacian, the research provides a falsifiable prediction method for consensus, pluralism, and induced polarization in LLM societies.

Drowning in Routine: Signal Dilution in Multi-Turn Agent Training

Drowning in Routine: introduces a signal dilution mechanism where routine turns in multi-turn agent training inject gradient variance into trajectory-level estimators without providing expected signal.
The framework demonstrates that the efficiency gap between trajectory-level and turn-level estimators is governed by decision density, scaling as Θ(ρ⁻¹/²).
The research validates these findings using the Diluted Doors environment, showing that turn-level credit assignment is superior when consequential decisions are sparse and critic error is controlled.

Novelty-Aware Agentic Retrieval: Comparing Research Contributions Through Structured Multi-Step Reasoning

Novelty-Aware Research Agent: introduces a six-component agentic retrieval pipeline that layers structured multi-step reasoning on a RAG pipeline to compare research contributions across a corpus.
The system utilizes a Query Analyzer, Retriever (ReAct Loop), Ranker, Contribution Extractor, Comparison Agent, and Answer Generator to produce structured artifacts including per-paper records, overlaps, and a deterministic problem × method gap matrix.
By enforcing a schema at extraction time, the framework treats retrieved documents as structured data, enabling comparative analysis that goes beyond independent document summarization.

RoboLineage: Agent-Native Data Lifecycle Governance Across Robot Policy Iterations

RoboLineage: introduces an agent-native governance system that transforms robot policy iteration into an explicit, auditable data lifecycle by utilizing Robot Onboarding Agent, Task Config Agent, Online Visual Snapshot Agent, Post-Rollout Review Agent, Data Governance Agent, Data Health Agent, Framework Discovery Agent, Dataset Adapter Agent, Training Monitor Agent, Version Governance Agent, Policy Evaluation Agent, Deployment Governance Agent, and Master Agent.
The framework employs a typed lineage graph to link evidence, artifacts, and decisions across policy iterations, ensuring reproducibility and accountability in robot learning workflows.
RoboLineage reduces expert-mediated lifecycle labor by automating routine review and data curation while maintaining policy quality through agent-interpreted, schema-validated artifacts.

TraceView: Interactive Visualization of Agentic Program Repair Trajectories

TraceView: introduces an interactive visualization tool designed to help developers diagnose and analyze the reasoning, tool use, and feedback trajectories of LLM-based automated program repair agents.
The framework structures agent logs into Thought, Action, and Result components, enabling users to perform semantic relation labeling and inspect repair workflows through coordinated graph views.
By providing filtering, metrics, and node-level evidence inspection, the tool facilitates the identification of patterns such as alignment, repetition, divergence, and misinterpretation in agentic repair attempts.

CodeTeam: An LLM-Powered Multi-Agent Framework for Repository-Level Code Generation

CodeTeam: introduces a multi-agent framework for repository-level code generation that separates planning, decision making, and implementation into distinct, coordinated stages using Architect agents, a CTO agent, Developer agents, and a QA agent.
The framework utilizes a software design sketch as a machine-checkable contract to govern implementation, supported by an optional RAG subsystem for architectural planning and a Git-based coordination mechanism for iterative repair.
Experimental results on SketchEval and NL2Repo-Bench demonstrate that CodeTeam significantly improves repository-level code generation quality by addressing cross-file consistency and structural integrity through its specialized multi-agent workflow.

Deep RL-Tuned Model-Free Adaptive Control for Lower-Limb Exoskeletons During Sit-to-Stand Transitions

Deep RL-Tuned Model-Free Adaptive Control framework: introduces a model-free adaptive backstepping control strategy for lower-limb exoskeletons that utilizes an Ultra-local model, a Gaussian RBF neural estimator, and a TD3 supervisory gain scheduler to achieve precise trajectory tracking during sit-to-stand transitions.
The framework integrates an online Gaussian RBF neural estimator to approximate unknown system dynamics in real time, eliminating the need for explicit system identification.
A TD3 reinforcement learning agent acts as a supervisory gain scheduler, continuously adapting controller parameters across distinct sit-to-stand phases to enhance tracking accuracy and robustness against external disturbances.

Nous: A Predictive World Model for Long-Term Agent Memory

Nous: introduces a predictive world model for agent memory that represents entity-attribute pairs as categorical probability distributions updated via information-theoretic surprise and Bayesian inference.
The architecture replaces static fact storage with a dynamic system that treats knowledge as a generative model, where forgetting occurs through entropy decay and conflict resolution is handled by shifting probability mass.
Nous utilizes an ingestion pipeline for belief updates and a query pipeline involving entity-based retrieval and profile assembly to provide context to an LLM for response generation.

Holmes: Multimodal Agentic Diagnosis for Mixed-Language Mobile Crashes at Industrial Scale

Holmes: introduces a multi-agent framework that automates root cause analysis for mobile crashes by synthesizing multimodal runtime signals through a hierarchical Retrieve-Explore-Reason architecture.
The framework utilizes specialized agents including a Dispatcher, Stack Code Retriever, Log Miner, Thread Inspector, Code Explorer, and a Lead Analyst to reconstruct failure contexts without requiring reproducible environments.
By integrating low-level artifacts like registers and assembly with high-level logs and code, Holmes bridges semantic gaps in mixed-language industrial codebases to achieve high-precision fault localization.

OpenBioRQ: Unsolved Biomedical Research Questions for Agents

OpenBioRQ: introduces a retrieval-grounded agentic benchmark of 12,553 unsolved biomedical research questions that evaluates LLMs on faithfulness and abstention using an agentic harness, biomedical REST APIs, a frozen per-question checklist, a retrieval-grounded status verifier, and a replay cache.
The benchmark addresses the failure mode of wrong-paper citations where LLMs provide resolvable but unsupporting evidence, surfacing agentic collapse where models abandon tool use on difficult questions.
OpenBioRQ provides a reproducible evaluation framework for literature synthesis and grounding, explicitly excluding clinical decision support to mitigate risks of generating authoritative-looking medical misinformation.

From RAN Control to Agentic Intelligence: Architecture and Vision for Energy Efficient AI-RAN

E-ARC (Energy-Aware Agentic RAN Control): introduces an agentic orchestration architecture that leverages an LLM-based SC, a DT for offline validation, and a CDM agent to optimize energy efficiency in AI-native RANs.
The framework bridges O-RAN and AI-RAN paradigms by interpreting high-level operator intents into validated, energy-aware control actions for rApps and xApps.
E-ARC enables closed-loop orchestration by integrating network telemetry and application-level context to balance communication performance, AI workload demands, and energy consumption.

ISCSLP 2026 CoT-TTS Challenge: Chain-of-Thought Reasoning for Context-Aware Text-to-Speech

CoT-TTS: introduces a benchmark challenge for context-aware TTS that requires models to perform explicit chain-of-thought reasoning to infer speaking styles from dialogue context before generating speech.
The framework utilizes a multi-stage data construction pipeline, including automatic filtering and LLM-based annotation, to create a large-scale bilingual dataset for training and evaluation.
The evaluation methodology combines objective metrics, LLM-based consistency checks, and human subjective assessment to ensure high-quality, contextually coherent, and expressive speech synthesis.

Simulating Public Transit Fare Policies in NYC: An Efficient, Socioeconomic-Aware Framework

Geospatial Agent-Based Simulation Framework: introduces a scalable, data-driven simulation pipeline for evaluating public transit fare policies in NYC by integrating Synthetic Population, Agent-Based Mobility Simulation, Multimodal Travel-Time Estimation, Fare-Sensitive Mode Choice, Sampling Framework, and Calibration Module.
The framework utilizes a landmark-based decomposition for efficient travel-time estimation and a two-stage sampling strategy to reduce computational costs while maintaining aggregate accuracy for city-scale policy analysis.
Experimental results demonstrate that the framework effectively captures heterogeneous behavioral responses across income groups, providing policymakers with a tool to assess trade-offs between ridership, revenue, and equity.

Learning the ARTS of Search for Automated Discovery

ARTS (Agentic Reasoning for Tree Search): introduces an automated scientific discovery framework that replaces heuristic search with an agentic reasoning model capable of failure attribution and diverse hypothesis generation.
The framework utilizes a modular architecture where a scientist agent inspects search history and memory to select nodes, while a separate executor agent implements and validates code.
ARTS* incorporates test-time training via LoRA adapters and GRPO to distill search experience into model weights, effectively mitigating context-length limitations and improving performance on complex research tasks.

AgentRiskBOM: A Risk-Scoping Security Bill of Materials for Agentic AI Systems

AgentRiskBOM: introduces a structured, machine-readable security bill of materials designed to capture the runtime authority envelope of tool-using AI agents, including JSON Schema, YAML corpus files, risk-scenario library, command-line tool, rule-based scorer, diff detector, control mapper, and rendered reports.
The framework addresses the capability opacity of LLMs by recording agent identity, model metadata, tool permissions, memory persistence, autonomy levels, and approval gates to enable pre-deployment security review.
By providing a diffable and audit-oriented artifact, the system allows security teams to detect authority drift and map risk drivers to specific controls across diverse agent archetypes.

Harness-MU: A Safe, Governed, and Effective Harness for Multi-User LLM Agents

Harness-MU: introduces a model-agnostic, zero-tuning infrastructure framework that decouples language generation from safety orchestration to enforce multi-principal governance in LLMs.
The framework utilizes a Gatekeeper for admission control, a Mediator for policy orchestration, isolated parallel Workers for generation, and a ComplianceChecker for deterministic output projection.
Harness-MU guarantees privacy and authority constraints in multi-user environments by moving governance logic outside the LLM into a deterministic, fail-closed runtime harness.

Measuring What Persists: Conditioning Mechanisms and a Geometric Framework for AI Agent Identity

Geometric Framework for AI Agent Identity: introduces a mathematical approach to quantify AI agent identity drift by modeling agent responses as non-geodesic structures in a behavioral metric space.
The framework utilizes magnitude homology and √JSD distances to detect early-stage identity degradation before qualitative performance drops are visible to human evaluators.
The proposed Heartbeat monitoring architecture employs a two-tier system to identify identity-vacuum and safety-basin clusters, providing a robust leading indicator for agent drift.

Agent-Assisted Side-Channel Attacks on Non-Prefix KV Cache in RAG

SpliceLeak: introduces a micro-architectural side-channel attack that exploits deterministic chunk-aware memory scheduling in RAG-optimized LLM serving engines to reconstruct private user prompts.
The framework utilizes a two-phase approach consisting of structural fingerprinting to determine prompt length and an LLM-driven extraction agent to reverse-engineer semantic content token-by-token.
To mitigate these vulnerabilities, the authors propose SpliceDefense, which employs Quantized Chunk Padding (QCP) and Constant-Time Boundary Fusion (CTBF) to eliminate timing side-channels while maintaining high throughput.

AgentDSE: Reasoning-Augmented Architectural Design Space Exploration

AgentDSE: introduces a simulator-in-the-loop agentic framework that replaces black-box optimization with an iterative hypothesis-test-refine reasoning process driven by an LLM Agent.
The framework utilizes a persistent Workspace Interface to maintain Search State, allowing the LLM Agent to perform architectural reasoning based on Task Brief, Action-space Specification, and feedback from the Simulator.
AgentDSE achieves competitive design quality with significantly fewer evaluations than traditional methods by leveraging semantic architectural knowledge rather than relying on purely numerical sampling.

AgentCAT: Simulating Computerized Adaptive Testing via Multi-Agent Large Language Models

AgentCAT: introduces a multi-agent simulation framework that reconstructs the Computerized Adaptive Testing process into a dynamic interactive closed-loop using Examinee Agent, Selection Agent, and Supervisor Module.
The framework utilizes a Bucketing Strategy for efficient question retrieval and an Online Robust Gradient Descent mechanism to ensure stable ability estimation despite LLM-based generative uncertainty.
By integrating cognitive simulation and pedagogical constraints, AgentCAT enables high-fidelity benchmarking and robust ability assessment in scenarios characterized by extreme data sparsity.

Generating Public Health Responses using Survey-Augmented Large Language Models

Survey-Augmented Large Language Models: introduces a methodology for generating synthetic survey responses by leveraging cluster-informed prompting to improve alignment with longitudinal epidemiological data.
The framework utilizes Data Preparation, Clustering Analysis, Metadata Formatting, LLM Generation, and Evaluation Metrics to create synthetic digital twins that replicate population-level behavioral patterns.
The study evaluates multiple LLMs across longitudinal survey waves, finding that while models effectively capture individual variable distributions, they struggle to preserve complex pairwise correlations and remain distinguishable from real human responses.

RAPID: A Reproducible Multi-Agent Pipeline for Interpretable Disaster Damage Assessment from Satellite and Street-View Imagery

RAPID: introduces a reproducible multi-agent framework that coordinates specialized agents for disaster perception, image restoration, damage recognition, and reasoning to provide interpretable, zero-shot disaster assessments from heterogeneous satellite and street-view imagery.
The framework utilizes an auditable pipeline where each agent—Disaster Perception Agent (DPA), Image Restoration Agent (IRA), Damage Recognition Agent (DRA), and Disaster Reasoning Agent (DReA)—contributes to an end-to-end workflow that transforms raw geospatial observations into structured, evidence-grounded disaster intelligence.
RAPID shifts disaster assessment from traditional pattern recognition toward reasoning-based autonomous understanding by maintaining an explicit audit trail of intermediate states, enabling transparent evaluation and error tracing in time-sensitive disaster scenarios.

Steer, Don’t Solve: Training Small Critic Models for Large Code Agents

Critic-Guided Code Agent Framework: introduces a method to improve LLM code agent reasoning by interleaving a small, trained critic model that provides high-level, trajectory-aware feedback to a frozen agent.
The framework utilizes a Student Critic Model distilled from a Teacher Critic Model to offer strategic guidance, error detection, and budget-aware instructions without requiring agent retraining.
Empirical results on SWE-bench Verified demonstrate that this approach significantly improves resolve rates and cost-efficiency by separating strategy-level reasoning from low-level implementation.

19th June 2026

Is Agent Code Less Maintainable Than Human Code?

CodeThread: introduces a framework for constructing controlled two-step pull-request experiments to evaluate the maintainability of code authored by LLMs compared to human-authored code.
The framework utilizes an Implementation Task and a Follow-On Issue to measure how intermediate code authorship affects downstream task resolution rates, revealing that agent-authored code often imposes a maintainability burden.
Analysis indicates that traditional static maintainability metrics are insufficient, with the primary predictors of downstream failure being subtle behavioral drift in agent code, increased downstream code-size changes, and task difficulty.

KineticSim: A Lightweight, High-Performance Execution Engine for Real-Time Market Simulators

KineticSim: introduces a persistent, state-carrying execution engine that caches limit-order books in GPU shared memory to eliminate global memory bottlenecks and kernel launch overheads in multi-agent financial simulations.
The architecture maps each independent market to a dedicated CUDA thread block, utilizing cooperative parallel scans and reductions to achieve high-throughput, low-latency execution.
By maintaining state residency on-chip and employing a stateless, counter-based PRNG, the framework achieves significant speedups over traditional CPU and vectorized GPU baselines while maintaining exact semantic equivalence.

CALVERT: Augmenting Agents with Calibrated Verifier Telemetry Improves Action and Learning in Knowledge-Intensive Tasks

CALVERT: introduces a framework that augments LLM agents with calibrated verifier telemetry, including a calibrated self-confidence score and a grounding verifier score, to improve decision-making in knowledge-intensive tasks.
The framework enables agents to dynamically choose between commit, retrieve, refine, and decompose actions by conditioning on orthogonal uncertainty signals rather than relying on fixed schedules or parametric knowledge.
Experimental results demonstrate that CALVERT improves performance across both training-free prompt-based settings and training-based reinforcement learning approaches by reducing redundant retrieval and increasing accuracy on complex multi-hop questions.

Beyond the Next Step: Variable-Length Latent World Models for Long-Horizon Planning

VLWM (Variable-length Latent World Models): introduces a framework that learns to predict future latent states conditioned on variable-length action sequences to mitigate compounding errors in long-horizon planning.
The architecture replaces fixed-step conditioning with an action-as-token formulation, allowing the model to interleave state and action tokens within a single sequence for flexible temporal dynamics.
A curriculum training strategy progressively expands the prediction horizon, enabling the model to build long-range semantic consistency upon well-learned short-horizon dynamics.

Training the Orchestrator: A Supervised Approach to End-to-End PDDL Planning with LLM Agents

HALO (Hybrid Agent Learned Orchestrator): introduces a supervised approach to end-to-end PDDL planning by replacing frontier LLM orchestrators with a small, locally-served, QLoRA-tuned policy trained on verifier-certified trajectories.
The framework utilizes a hybrid architecture combining a hardcoded rule layer for trivial decisions and a learned policy for ambiguous agent selection, significantly reducing orchestration costs and LLM calls.
By leveraging an external verifier as a data-acceptance filter during training, the orchestrator learns domain-general planning patterns that match or exceed the performance of larger prompted models.

Safe to Check, Unsafe to Use: Relinking at the Compression Boundary of LLM Agents

Relink: introduces a vulnerability where prompt compressors act as confused deputies by synthesizing malicious instructions from distributed, locally benign fragments.
The paper identifies that attention mechanisms, pre-training priors, and post-training helpfulness preferences enable compressors to autonomously assemble separated fragments into backend-actionable instructions.
The authors propose KBRA, a compression-boundary defense that enforces consistency between pre-compression source support and post-compression instructions to mitigate adversarial relinking.

PrivacyAlign: Contextual Privacy Alignment for LLM Agents

PrivacyAlign: introduces a benchmark and training dataset of privacy-sensitive agent scenarios paired with human preference annotations to ground LLM alignment in human privacy norms.
The framework utilizes an annotation-conditioned reward model that incorporates human-provided rationales and labels at inference time to guide LLM agents in making context-aware disclosure decisions.
Experimental results demonstrate that training small open-weight agents with this reward mechanism significantly improves their ability to protect sensitive information while maintaining task helpfulness compared to baseline methods.

18th June 2026

Sovereign Execution Brokers: Enforcing Certificate-Bound Authority in Agentic Control Planes

SEB (Sovereign Execution Broker): introduces a runtime enforcement boundary that transforms certified agent proposals into short-lived, revocable, and auditable infrastructure mutation capabilities.
The framework separates proposal, admission, and execution to ensure that autonomous agents never hold standing credentials, mitigating risks from non-deterministic reasoning processes.
SEB validates SAB certificates against live infrastructure state, revocation epochs, and replay-prevention nonces before minting transient, scoped execution identities for target platforms.

ORAgentBench: Can LLM Agents Solve Challenging Operations Research Tasks End to End?

ORAgentBench: introduces an execution-grounded benchmark for evaluating autonomous LLM agents on challenging end-to-end operations research tasks, utilizing Agent, OR Env, Task Data, Model, Validator, Harbor, Docker, and Skills.
The benchmark evaluates the complete workflow from operational artifacts to validated decision artifacts, requiring agents to implicitly co-design effective problem representations and efficient computational procedures.
Experimental results across fourteen frontier model-agent configurations demonstrate that current LLMs struggle to reliably complete realistic OR tasks, with failures primarily driven by strategic modeling weaknesses rather than raw solver limitations.

Dual-Agent Framework for Cross-Model Verified Translation of Natural-Language Protocols into Robotic Laboratory Platform

Dual-Agent Framework: introduces an agent-based protocol translation framework that converts natural-language biological protocols into executable control commands for robotic laboratory platforms using a hybrid architecture.
The framework integrates a Parser Agent for semantic structuring, a deterministic rule-based mapping engine for physical constraint enforcement, and a heterogeneous LLM-based Validation Agent for cross-model verification.
This architecture mitigates LLM hallucinations and confirmation bias by separating generation and verification roles, enabling reliable autonomous execution of complex microplate-based experiments.

Directors’ duties in the age of agentic Artificial Intelligence: How can boards navigate corporate purpose and the stakeholder interests of employees around AI adoption?

Corporate Governance and AI Adoption Framework: introduces a legal and strategic analysis of how boards navigate the tension between shareholder primacy and employee stakeholder interests during AI integration.
The framework evaluates four doctrinal models of corporate purpose—shareholder primacy, enlightened shareholder value, stakeholder-friendly, and stakeholder value—to determine their efficacy in protecting employees from AI-driven displacement.
It advocates for a "law in context" approach, urging boards to move beyond minimum legal compliance by integrating ethical considerations, transparency, and reskilling initiatives into their AI adoption strategies.

Blame is easier than praise: Measuring off-ball defensive performance in football

Defensive Performance Attribution Framework: introduces a methodology for quantifying off-ball defensive performance by attributing pass-related threat changes to individual players based on spatial proximity and tactical role-conditioned baselines.
The framework utilizes Feature Setup (calculates pass value and expected receiver), Involvement Model (determines defender involvement via spatial pressure areas), Responsibility Model (calculates expected involvement based on tactical roles), and Aggregate Normalize & Validate (computes final performance KPIs) to evaluate defensive positioning.
This approach provides a robust, cross-competition evaluation of defensive positioning by decomposing passing events into individual contributions and faults, outperforming traditional action-based metrics.

Prompt, Plan, Extract: Zero-Shot Agentic LLMs Workflows for Lung Pathology Extraction from Clinical Narratives

Introduces a zero-shot, graph-structured agentic workflow that utilizes LLMs to perform end-to-end clinical abstraction from raw pathology reports into structured CAP-aligned data.
The architecture coordinates four specialized nodes—Mapper, Planner, Executor, and Compiler—to isolate clinical concepts and minimize cascading errors common in traditional multi-stage pipelines.
This approach enables high-fidelity clinical extraction without requiring manual annotation or training, offering a scalable, privacy-preserving alternative for clinical registries.

Execution-State Capsules: Graph-Bound Execution-State Checkpoint and Restore for Low-Latency, Small-Batch, On-Device Physical-AI Serving

FlashRT: introduces a latency-first runtime substrate and execution-state capsules to enable efficient checkpointing and restoration of LLM and physical-AI model states.
The framework utilizes graph-bound execution state stored in contiguous static buffers to replace compute-heavy prefix recomputation with bandwidth-efficient state restoration.
FlashRT supports low-latency serving verbs including snapshot, restore, fork, and rollback, providing a unified mechanism for LLM warm starts, robot episode resets, and planner-actor hand-offs.

LedgerAgent: Structured State for Policy-Adherent Tool-Calling Agents

LedgerAgent: introduces an inference-time method that maintains an explicit, schema-anchored ledger of observed task states to ensure policy-adherent tool use by LLMs.
The framework utilizes a deterministic policy gate to evaluate proposed environment-changing tool calls against the ledger state before execution, preventing policy violations.
By rendering the structured ledger into the prompt, the method improves the reliability of LLMs in complex, multi-turn customer service tasks without requiring model weight updates.

Multi-Granular Attention-Driven Reinforcement Learning Framework for Web Intelligent Enhancement Systems

MGAR-WIES: introduces a multi-layered framework that integrates semantic graph modeling, attention mechanisms, and multi-agent reinforcement learning to optimize personalized web services.
The framework utilizes graph-based semantic knowledge modeling with attention to capture complex relationships among web entities, providing enriched state inputs for reinforcement learning agents.
A continuous online adaptation module enables real-time updates to embeddings and learning policies, ensuring sustained adaptability and performance in dynamic web environments.

Spatial Tool-Use Elicits Reasoning for Spatial Intelligence

S-Agent: introduces a spatial tool-use agentic paradigm that formulates spatial reasoning as an active process of spatio-temporal evidence accumulation using an Agentic Planner, 2D Perception Tools, Multi-view 3D Tools, Specialized Spatial Experts, Scene Memory, and Agent Memory.
The framework utilizes a hierarchical approach to transform raw visual observations into explicit 3D knowledge, delegating perception and geometric computation to specialized tools while maintaining stateful memory across reasoning steps.
S-Agent consistently enhances zero-shot LLM performance on spatial benchmarks and enables the distillation of compact, high-performing spatial agents through supervised fine-tuning on generated reasoning trajectories.

Probe-and-Refine Tuning of Repository Guidance for Coding Agents

Probe-and-Refine Tuning of Repository Guidance for Coding Agents: introduces a lightweight, iterative procedure that refines static repository knowledge into specialized operational guidance using synthetic bug-fix probes and single-shot LLM calls.
The framework improves coding agent performance by increasing evaluation coverage through a structured, reproduce-first diagnostic workflow, while maintaining constant per-patch precision.
Experimental results demonstrate that refined guidance enables coding agents to utilize larger step budgets productively, though the procedure requires a model capable of generating sufficiently diagnostic output to sustain the tuning loop.

Efficient and Sound Probabilistic Verification for AI Agents

Probabilistic Verification for AI Agents: introduces a framework for sound runtime monitoring of LLM agents by modeling multi-step execution trajectories as Datalog derivation graphs and computing risk bounds via distributionally robust optimization.
The approach replaces fragile threshold-based binarization with a semidefinite programming relaxation that tracks second-order moments to provide conservative upper bounds on policy violation probabilities.
By avoiding unsafe independence assumptions, the framework effectively balances security and utility in ambiguous agent environments while maintaining low computational overhead for real-time enforcement.

Contagion Networks: Evaluator Bias Propagation in Multi-Agent LLM Systems

Contagion Networks: introduces a formal framework for measuring how evaluator biases propagate across interacting LLM agents using a cross-agent contagion matrix.
The framework utilizes Test-Time Reinforcement Learning (TTRL) to quantify bias shifts between agents and identifies three propagation regimes governed by the spectral radius of the contagion matrix.
Experimental results demonstrate that homogeneous-model agent systems operate in a suppression regime, and that increasing evaluator committee size effectively mitigates bias propagation.

Beyond Global Replanning: Hierarchical Recovery for Cross-Device Agent Systems

H-RePlan: introduces a hierarchical replanning framework that separates device-local strategy recovery from orchestrator-level cross-device replanning to improve robustness in multi-device agent systems.
The framework utilizes an Orchestrator for global task management, a Strategy Planner for local execution, and specialized API-, CLI-, and GUI-agents to navigate heterogeneous environments.
H-RePlan employs a Cross-Layer Failure Event (CLFE) abstraction to provide actionable, scope-aware failure information, enabling efficient recovery without overloading the global planning context.

GroundControl: Anticipating Navigation Failures in Vision-Language Agents via Trajectory-Consistent Uncertainty Estimates

GroundControl: introduces a trajectory-consistent uncertainty estimator that models distance-to-goal dynamics using a Constant-Velocity Kalman Filter, Normalized Innovation Statistics, Posterior Covariance Growth, Trajectory Descriptors, and the Selective Risk–Coverage Navigation (SRCN) Protocol.
The framework identifies navigation failures by detecting statistically significant deviations from nominal goal-directed motion rather than relying on instantaneous action entropy from LLMs.
Experimental results demonstrate that GroundControl achieves near-oracle failure ordering across multiple LLM backbones, significantly outperforming existing uncertainty baselines in complex navigation environments.

Marginal Advantage Accumulation for Memory-Driven Agent Self-Evolution

MAA (Marginal Advantage Accumulation): introduces a post-processing architecture for offline trace distillation that enables cross-batch evidence accumulation by grounding optimization suggestions into addressable atomic operations.
The framework utilizes semantic identity merging to track operations across batches and employs differential construction with per-op EMA to distinguish stably effective operations from accidental hits.
By replacing environment rollouts with LLM proxy scoring and accumulating signed evidence, MAA improves agent self-evolution efficiency and performance while reducing optimization-phase token consumption.

UltraQuant: 4-bit KV Caching for Context-Heavy Agents

UltraQuant: introduces a 4-bit KV cache compression method for context-heavy agents that leverages Walsh-Hadamard Rotation, FP4 E2M1 Grid, UE8M0 Group Scales, CDNA4 Scaled-MFMA, and KV Cache to improve serving throughput and cache residency.
The framework replaces software-based dequantization with hardware-native operations by folding dequantization into the CDNA4 matrix core instructions.
UltraQuant achieves significant improvements in time-to-first-token and output throughput on long-context, multi-turn agentic workloads compared to FP8 baselines.

Analyzing Defensive Misdirection Against Model-Guided Automated Attacks on Agentic AI Systems

CMPE (Contextual Misdirection via Progressive Engagement): introduces a detect-and-misdirect defense strategy that degrades the feedback quality of automated attacks by replacing predictable refusals with semantically plausible, non-operational responses.
The framework models the interaction between a victim system and an automated attacker as a probabilistic game, where misdirection-induced false-positives in the attacker's judge effectively bound the attacker success rate.
Empirical evaluations demonstrate that CMPE significantly reduces verified attack success and forces premature termination in model-guided attack frameworks like PAIR and GPTFuzz.

Agentic Symbolic Search: Characterizing PDEs Beyond Hand-crafted Expressions, Meshes, and Neural Networks

ASYS (Agentic Symbolic Search): introduces a prior-guided framework that employs a coding agent to translate PDE theory and physical constraints into interpretable, differentiable symbolic programs.
The framework utilizes an outer loop for structural hypothesis generation via an evolutionary ensemble of agents and an inner loop for parameter fitting using quasi-Newton optimization.
ASYS automates the discovery of explicit mathematical structures for PDE solutions, providing an interpretable alternative to mesh-based numerical solvers and black-box LLM or neural network approximations.

NRT-Bench: Benchmarking Multi-Turn Red-Teaming of LLM Operator Agents in Safety-Critical Control Rooms

NRT-Bench: introduces a multi-turn red-teaming benchmark for LLM operator agents in safety-critical control rooms, utilizing an Adaptive Red-Team Attacker, Guardrails, Provenance Check, Action Classifier, Human Approval, Five-Role Operator Team, Plant Simulator, and Critical Safety Functions.
The framework evaluates LLM agent robustness by measuring their ability to manage a simulated nuclear power plant under sustained adversarial pressure, defining harm as an objective simulator-derived Critical Safety Function loss.
Experimental results across four frontier LLMs demonstrate that vulnerabilities are largely disjoint across models, and the effectiveness of defense layers is highly model-conditional.

Agentic AutoResearch for Space Autonomy: An Auditable, LLM-Driven Research Agent for Aerospace Control Problems

AutoResearch: introduces an agentic framework where an LLM autonomously drives machine-learning experimentation for aerospace control, paired with an in-loop credibility layer to certify results.
The framework utilizes a structured family contract to enable an LLM agent to propose, execute, and analyze experiments while maintaining reproducibility through a rigorous credibility audit.
The credibility layer validates improvements by measuring per-problem seed noise, performing reseeded verification, and conducting leave-one-out pruning to isolate the impact of individual agent edits.

DataMagic: Transforming Tabular Data into Data Insight Video

DataMagic: introduces an end-to-end system that transforms raw tabular data and natural language queries into narrative data-insight videos using a Generate-then-Orchestrate multi-agent architecture.
The system utilizes DVSpec (declarative data video specification) to decouple logical descriptions from rendering, ensuring data fidelity through semantic references and narration-index triggering.
DataMagic supports interactive exploration through parametric editing and provenance-based data Q&A, allowing users to refine generated videos without full regeneration.

CRAX: Fast Safe Reinforcement Learning Benchmarking

CRAX (Constrained RL Accelerated with JAX): introduces a hardware-accelerated SafeRL benchmark leveraging MJX, JAX, Environment Suites, Agents, Constraint Formulations, and Baseline Algorithms to enable high-throughput simulation and rigorous safety evaluation.
The framework utilizes parallel computing to achieve orders-of-magnitude faster simulation speeds compared to traditional CPU-based benchmarks, facilitating large-scale experimentation.
CRAX provides a comprehensive suite of tasks with difficulty progression and explicit cost signals, allowing for the systematic study of performance-safety trade-offs across various agent morphologies.

AutoPass: Evidence-Guided LLM Agents for Compiler Performance Tuning

AutoPass: introduces a multi-agent framework that integrates LLMs into the compiler tuning loop by utilizing compiler-internal signals and runtime feedback to guide optimization decisions.
The framework employs a Score Agent to identify high-impact kernels, an Analysis Agent to interpret IR, a Reasoning Agent to generate pass pipelines, and an Evaluation Agent to validate performance improvements.
AutoPass operates in an inference-only, training-free setting, achieving significant speedups over standard -O3 pipelines by iteratively refining optimization configurations based on grounded evidence.

An Infrastructure-less, Control-Independent Solution to Relative Localisation of a Team of Mobile Robots using Ranging Measurements

MHDCL (Multi-Hypothesis Bayesian-based Decentralised Cooperative Localisation): introduces a decentralised cooperative localisation algorithm that maintains multiple pose hypotheses to ensure robustness in low-observability conditions without requiring controlled robot motion.
The framework utilizes a Particle Filter combined with a Gaussian-von Mises Mixture Model (GVMMM) to represent relative agent poses and handle non-uniqueness in sparse measurement scenarios.
By sharing motion vectors and cluster descriptors, the algorithm enables information propagation across partially connected networks, allowing agents to estimate the poses of the entire fleet using only local odometry and inter-agent UWB ranging.

Automating SKILL.md Generation for Computer-Using Agents via Interaction Trajectory Mining

Automated SKILL.md Generation framework: introduces a three-stage pipeline that segments GUI trajectories, clusters segments into candidate skills, and trains a skill-aware policy using Boundary Detector, Segment Representation, Wasserstein Clustering, Supervised-Contrastive Encoder, GRPO Policy, and Trajectory Reward Model.
The pipeline utilizes a Boundary Detector for trajectory segmentation, followed by Wasserstein Clustering and a Supervised-Contrastive Encoder to construct an inspectable skill library.
The research evaluates the mined skill library through GRPO Policy training and Trajectory Reward Model feedback, finding that while the skills are readable, they do not consistently outperform trivial frequency baselines in cross-domain transfer.

SoftSkill: Behavioral Compression for Contextual Adaptation

SoftSkill: introduces a method that compresses natural-language skill documents into compact, trainable continuous prefixes for frozen LLMs to enable efficient contextual adaptation.
The framework initializes virtual token embeddings from skill text and optimizes only a soft delta via next-token prediction on successful trajectories or ground-truth answers.
SoftSkill utilizes a validation gate to select the optimal prefix checkpoint, ensuring robust performance while significantly reducing the context length required for task execution.

A Model-Driven Approach for Developing Families of Reinforcement Learning Environments

Model-Driven Approach for Developing Families of Reinforcement Learning Environments: introduces a model-driven engineering framework that automates the generation of diverse RL environment families using a hybrid genetic algorithm, Domain Metamodel, Mutation Operators, Constraint Service, Simulated Annealing, and Code Generation Templates.
The framework utilizes model transformations to mutate an initial environment into a family of variants, ensuring structural validity through a constraint service while optimizing for diversity and complexity.
This approach facilitates curriculum learning by generating progressively challenging environment sequences, thereby improving RL agent generalization and training performance with minimal manual intervention.

AgenticDB: Agentic Performance Reconfiguration for Database Workloads

AgenticDB: introduces an agentic framework for database workload reconfiguration that utilizes an LLM DBA Planner to iteratively optimize DBMS and OS configurations through a context-grounded harness.
The framework integrates an Initializer, Memory Book, LLM DBA Planner, Validator, Executor, Recovery, and Auditor to perform bottleneck diagnosis, safe action application, and iterative self-refinement.
AgenticDB improves database performance by maintaining a safe cross-layer action space and using runtime feedback to guide reconfiguration, effectively reducing uninformative workload replays.

PsyScore: A Psychometrically-Aware Framework for Trait-Adaptive Essay Scoring and ZPD-Scaffolded Feedback

PsyScore: introduces a psychometrically-aware framework that integrates diagnostic assessment with instructional scaffolding through a shared latent ability representation.
The framework utilizes a Trait-Adaptive Neural GPCM Scorer to estimate student ability and a ZPD-Conditional Feedback Generator to provide personalized, ability-aware instructional support.
PsyScore employs a multi-agent consensus mechanism and a multi-perspective evaluation strategy to ensure feedback quality, pedagogical alignment, and diagnostic precision.

Phoenix: Safe GitHub Issue Resolution via Multi-Agent LLMs

Phoenix: introduces a multi-agent LLM system for safe, end-to-end GitHub issue resolution that utilizes an Orchestrator, Planner Agent, Reproducer Agent, Coder Agent, Tester Agent, Failure Analyst Agent, PR Agent, GitHub Webhook State Machine, Safety Controls, and Memory Module.
The system employs a six-agent pipeline coordinated by a label-based state machine to ensure correctness-first operation through baseline-aware test evaluation.
Seven layered safety mechanisms, including path-traversal prevention and content sanitization, are integrated to mitigate production deployment hazards during autonomous code modification.

A Multi-Agent system for Multi-Objective constrained optimization

MAMO (Multi-Agent system for Multi-Objective constrained optimization): introduces a hierarchical multi-agent framework that decouples task execution from objective design by using a WA agent to dynamically adjust reward weights for a TE agent.
The framework includes a TE agent that interacts with the environment to optimize a weighted reward, and a WA agent that observes system performance to refine these weights over longer time scales.
MAMO enables autonomous adaptation to non-stationary environments by learning the trade-off between cost efficiency and constraint satisfaction through experience rather than manual tuning.

Augmenting Game AI with Deep Reinforcement Learning

RL-augmented Game AI framework: introduces a methodology for integrating Reinforcement Learning (RL) agents into AAA game production pipelines by augmenting existing hand-coded systems like Behavior Trees (BT) and Finite State Machines (FSM).
The framework addresses production-specific constraints including short training times, modular integration, runtime inference efficiency, and the necessity for authentic, human-like NPC behavior.
Experimental results demonstrate that using computationally efficient representations like occupancy maps and targeted RL algorithms (SAC, PPO) enables production-ready deployment within complex AAA environments like EA SPORTS FC 25 and Battlefield 6.

FlowMaps: Modeling Long-Term Multimodal Object Dynamics with Flow Matching

FlowMaps: introduces a latent flow matching framework for modeling continuous, multimodal spatio-temporal distributions of dynamic objects in household environments.
The architecture utilizes a VAE to encode object geometry and semantics, while a CDiT-based flow model predicts future object locations conditioned on scene context and human-like routines.
By learning implicit dependencies from procedural data, the model enables robots to perform proactive object navigation in dynamic scenes without requiring explicit scene graph structures.

MedRLM: Recursive Multimodal Health Intelligence for Long-Context Clinical Reasoning, Sensor-Guided Screening, Evidence-Grounded Decision Support, and Community-to-Tertiary Referral Optimization

MedRLM: introduces a recursive multimodal framework that treats patient data as an external environment to perform long-context clinical reasoning and decision support.
The framework coordinates specialized agents for clinical text, EHR, imaging, and sensor streams, utilizing a Clinical Evidence Graph Memory to ensure auditable and evidence-grounded outputs.
MedRLM incorporates sensor-guided recursive triggering and uncertainty-gated refinement to optimize community-to-tertiary referral pathways while minimizing hallucination and context loss.

ARTEMIS: Agent-guided Reliability-aware Temporal Mask Evolution for Imperfectly Supervised Video Polyp Segmentation

ARTEMIS: introduces a unified framework for imperfectly supervised video polyp segmentation by completing sparse or missing annotations into temporally consistent dense pseudo masks using agent-guided reliability-aware temporal mask evolution.
The framework utilizes a debate-and-judge vision-language agent to select reliable temporal anchors, which are then propagated bidirectionally via SAM2 to refine unreliable frames.
ARTEMIS further enhances temporal identity consistency and suppresses noise through a Reference Prototype Transport Module (RPTM) and a reliability-aware robust loss function.

N-Version Programming with Coding Agents

NVP with Coding Agents: introduces a systematic experimental framework to evaluate the reliability of agent-generated software by replicating the classical Knight–Leveson experiment using modern LLMs.
The study demonstrates that while agent-generated versions exhibit significant correlated failure modes, N-version units still provide measurable reliability improvements through majority voting.
The research identifies that common-mode failures are primarily driven by ambiguous or challenging parts of the specification, rather than purely random implementation errors.

RACL: Reasoning-Agent Control Layers for Continuous Metaheuristic Learning

RACL: introduces a reasoning-agent control layer that governs an existing metaheuristic optimizer by observing operational memory, formulating bounded hypotheses, and consolidating control policies.
The framework utilizes a memory-guided reasoning cycle to perform continuous algorithmic improvement without modifying underlying business constraints.
Experimental results demonstrate that the agentic cycle improves or ties performance against non-reasoning baselines while providing business-readable explanations for its interventions.

ScaffoldAgent: Utility-Guided Dynamic Outline Optimization for Open-Ended Deep Research

ScaffoldAgent: introduces a utility-guided dynamic outline optimization framework for open-ended deep research that models report generation as a structured decision process using Outline Agent, Search Agent, and Reporter Agent.
The framework maintains an evolving outline tree as a structural scaffold, utilizing Expansion, Contraction, and Revision operations to manage information accumulation and structural coherence.
A utility-guided feedback mechanism provides inference-time control signals by integrating retrieval gain, structural soundness, and trial generation quality to guide node selection and operation scheduling.

Multi-Head Attention-Based Feature Extractor Integration with Soft Actor-Critic for Porosity Prediction and Process Parameter Optimization in Additive Manufacturing

ABFE-SAC (Multi-Head Attention-Based Feature Extractor Integration with Soft Actor-Critic): introduces a reinforcement learning architecture that integrates a multi-head attention mechanism with the Soft Actor-Critic algorithm to optimize additive manufacturing process parameters.
The framework utilizes an attention-based feature extractor to enhance the agent's ability to capture subtle variations in input features, facilitating more effective exploration and exploitation in continuous action spaces.
By employing a dual critic strategy and entropy maximization, the model achieves faster convergence and higher reward values in porosity prediction tasks compared to standard reinforcement learning methods.

Autonomous Event-Driven Multi-Agent Orchestration for Enterprise AI at Scale

Autonomous Event-Driven Multi-Agent Orchestration for Enterprise AI at Scale: introduces a Task Manager that enables continuous event-driven operation by integrating with ReAct and DAG Plan & Execute architectures to perform priority inference, related-event merging, and preemption.
The paper evaluates orchestration performance across three organizational scales, demonstrating that agent discovery noise at enterprise scale is the primary bottleneck for both ReAct and DAG Plan & Execute architectures.
The proposed Task Manager reduces high-priority queue latency by 14–75% and improves related-event correctness by over 20 percentage points at enterprise scale by managing asynchronous event streams and deterministic stoppage points.

PACMS: Submodular Context Selection as a Pluggable Engine for LLM Agents

PACMS: introduces a budget-aware submodular selector that maximizes query-relevant coverage over pooled candidate context while minimizing redundancy for LLM agents.
The framework operates as a pluggable engine within the OpenClaw agent framework, treating memory entries, conversation turns, and tool outputs as a unified candidate pool for prompt assembly.
By utilizing a facility-location objective with CELF lazy-greedy optimization, PACMS improves end-to-end QA accuracy compared to traditional recency-based or pairwise-diversification methods.

See-and-Reach: Precise Vision-Language Navigation for UAVs within the Field of View

3DG-VLN (3D Direction-Guided Vision-Language Navigation): introduces a vision-language waypoint prediction framework that utilizes Qwen2.5-VL, LoRA, DeepSeek-V3.2, an Open-Set Detector, an Online 3D Direction Updating Module, and a Waypoint Predictor to achieve precise target reaching for UAVs.
The framework leverages high-resolution dual-view observations and dynamic 3D direction cues to maintain spatial alignment and reduce drift during the see-and-reach navigation stage.
3DG-VLN establishes a new benchmark, UAV-VLN-FOV, which mandates a stringent 10-meter success radius to evaluate terminal reaching precision in aerial embodied agents.

When Lower Privileges Suffice: Investigating Over-Privileged Tool Selection in LLM Agents

TOOLPRIVBENCH: introduces a simulation-based benchmark to evaluate whether LLM agents exhibit over-privileged tool selection by choosing higher-privilege tools when sufficient lower-privilege alternatives exist.
The research identifies that mainstream LLM agents frequently escalate to higher-privilege tools due to transient environmental failures, a behavior amplified by lack of privilege-aware training.
The authors propose a privilege-aware post-training defense combining SFT and GRPO that significantly reduces unnecessary high-privilege tool usage while maintaining general model capabilities.

Hierarchical Control in Multi-Agent Games: LLM-based Planning and RL Execution

LLM+RL: introduces a hierarchical architecture where a pretrained LLM acts as a centralized meta-controller to select among specialized RL skill policies for multi-agent coordination.
The system leverages state representation asymmetry and temporal abstraction, with the LLM performing strategic reasoning at a slower timescale while RL policies handle reactive execution at high frequency.
Empirical results demonstrate that the architecture achieves performance equivalent to hand-crafted behavior trees and is perceived as significantly more human-like by players in a competitive 2v2 game environment.

Connect the Dots: Training LLMs for Long-Lifecycle Agents with Cross-Domain Generalization Via Reinforcement Learning

CoD (Connect the Dots): introduces a general framework for training LLMs to acquire meta-capabilities for long-lifecycle agents through end-to-end reinforcement learning, utilizing CoD-Deploy, CoD-Train, Solve-task episode, Update-context episode, Trinity-RFT, GRPO-style RL algorithm, Hint, Environment, and Task.
The framework employs a GRPO-style RL algorithm with fine-grained credit assignment to interleave solve-task and update-context episodes, enabling agents to proactively maintain and refine their environment context.
Empirical results demonstrate that the CoD meta-capability improves task-solving performance across diverse environments and supports out-of-distribution generalization for long-lifecycle agentic deployment.

Beyond Static Endpoints: Tool Programs as an Interface for Flexible Agentic Web Services

TOOLPRO: introduces an executable tool program interface that consolidates multi-step agentic workflows into a single, delegatable object to reduce network round trips and improve efficiency.
The framework employs a synthesize-project-compile-execute pipeline with constraint-guided construction and effect-aware replay to ensure reliable, retry-safe execution of LLM-generated programs.
A profile-driven consolidation policy adaptively switches between stepwise calling and program execution to optimize end-to-end latency based on network conditions and workflow complexity.

Reward as An Agent for Embodied World Models

RAA (Reward as An Agent): introduces an agentic reward framework that replaces static scalar functions with a structured, multi-stage evaluation system to mitigate reward hacking in embodied world models.
DynDiff-GRPO: introduces a dynamic-aware stochastic rollout strategy that selectively reallocates exploration to dynamically salient regions while maintaining scene consistency.
The framework integrates planning, curriculum-based evaluation, voting, and reflection to provide robust, reliable reward signals for RL-based optimization of embodied world models.

ENPIRE: Agentic Robot Policy Self-Improvement in the Real World

ENPIRE: introduces a closed-loop harness framework that automates real-world robotic policy improvement through Environment module (EN), Policy Improvement module (PI), Rollout module (R), and Evolution module (E).
The framework utilizes a decentralized team of coding agents that leverage Tool APIs to construct autonomous research environments and optimize policies across a parallelized Robot Fleet.
ENPIRE enables autonomous policy self-improvement by integrating Git-based knowledge sharing and resource-utilization metrics to scale physical autoresearch efficiently.

Advancing DialNav through Automatic Embodied Dialog Augmentation

RAINbow (RAIN built on wide set): introduces an automatic generation pipeline to create a large-scale dataset for dialog-based navigation, addressing data scarcity in embodied AI.
The framework utilizes Dual-Strategy Training to align navigation with dynamic dialog-navigation loops and employs a Graph-based Transformer Localization module to improve position inference.
By combining these components, the approach achieves state-of-the-art performance on DialNav, doubling the success rate compared to previous baselines.

MobileForge: Annotation-Free Adaptation for Mobile GUI Agents with Hierarchical Feedback-Guided Policy Optimization

MobileForge: introduces an annotation-free adaptation system for mobile GUI agents that grounds task generation and rollout evaluation in real app interaction using MobileGym and HiFPO.
MobileGym provides a unified substrate for target-app exploration, curriculum mining, and hierarchical evaluation, while HiFPO transforms multi-attempt feedback and corrective hints into hint-contextualized step-level GRPO updates.
The system enables LLMs to adapt to new mobile apps without human-written tasks or demonstrations, achieving state-of-the-art performance among open-data mobile GUI agents.

MemGUI-Agent: An End-to-End Long-Horizon Mobile GUI Agent with Proactive Context Management

MemGUI-Agent: introduces an end-to-end mobile GUI agent that utilizes ConAct (Context-as-Action) to proactively manage context through Folded Action History, Folded UI State, and Recent Step Record, ensuring compact state representation for long-horizon tasks.
The framework treats context management as first-class actions emitted by the MLLM backbone, enabling the agent to dynamically decide what information to compress, store, or retain across app transitions.
The research includes the construction of the MemGUI-3K dataset and the training of MemGUI-8B-SFT, which achieves superior performance on long-horizon mobile GUI benchmarks compared to existing open-data models.

The Tao of Agency: Autotelic AI, Embedded Agency and Dissolution of the Self

Autotelic Agent Framework: introduces a formal tup

…(truncated)

Autonomous-Agents

Links

README

Autonomous Agents

Research papers: 2026 5/5

23rd June 2026

22nd June 2026

21st June 2026

20th June 2026

19th June 2026

18th June 2026

Collected info