HDATF
English
Start a conversation
Menu

Paper Archive

Every archived paper with its summary, highest number first.

Papers 1,430Archive updated Research MonitoringBenchmarksRSS feed
  1. 181Agents / Coding / RAGarXiv:2605.15184

    Is Grep All You Need? How Agent Harnesses Reshape Agentic Search

    • Prior work often evaluates retrieval strategies for LLM agents in isolation rather than within a full iterative agent workflow.
    • The interaction between retrieval strategies, agent structure, custom versus provider-native CLI, and tool-calling paradigms, inline versus file-based result passing, has remained largely unexplored.
    • Understanding how retrieval strategies behave as corpus noise increases has been limited, even though this is an important aspect of real-world agent deployments.
    • We conducted a multifaceted empirical study comparing lexical retrieval, grep, and semantic retrieval, vector search, across different agent harnesses and tool-calling structures.
    • The evaluation used a subset of 116 questions from the LongMemEval benchmark and focused on multi-session conversations with varying levels of irrelevant distractor content.
    • We evaluated five different LLMs and used an auxiliary LLM judge to ensure consistent and objective agent accuracy across all experimental conditions.
    AbstractPDF
  2. 180LLMs / Architecture / Long ContextarXiv:2605.06554

    Long Context Pre-Training with Lighthouse Attention

    • The quadratic time and memory complexity of scaled dot-product attention, Theta(N^2), makes it computationally infeasible to train causal Transformers on extremely long sequences such as 128K or 1M-plus tokens.
    • Existing sparse-attention methods for pretraining are often asymmetric, pooling only keys and values, or structurally entangled, which prevents reuse of highly optimized dense attention kernels such as FlashAttention.
    • It remains a major challenge to ensure that a model pretrained with sparse attention can function effectively as a full dense-attention model at inference time.
    • The paper introduces a four-stage pipeline that wraps the attention kernel so standard FlashAttention can operate on dynamically compressed subsequences: pyramid construction, scoring and selection, gather-sequence attention, and scatter-restore reconstruction.
    • It applies symmetric average pooling to queries, keys, and values across multiple pyramid levels, and combines a parameter-free projection-norm scorer with a non-differentiable top-k selection step for quasi-quadratic processing.
    • It uses a two-stage training scheme: first train with Lighthouse Attention for efficiency, then run a short resume stage with full dense SDPA at inference time to restore and optimize the model's full attention capacity.
    AbstractPDF
  3. 179Agents / Security / SkillsarXiv:2605.00424

    Skills as Verifiable Artifacts: A Trust Schema and a Biconditional Correctness Criterion for Human-in-the-Loop Agent Runtimes

    • Agent skills, structured packages of instructions, scripts, and reference material that augment an LLM without modifying the model itself, have moved from convenience features to first-class deployment artifacts.
    • The runtimes that load them inherit the same problem faced by package managers and operating systems: when content claims to do something, the runtime must decide whether to trust it.
    • The paper makes its core point explicit from the start: a skill is untrusted code until it is verified, and the runtime that loads it should enforce that default rather than infer trust from signatures, permission levels, or source registries.
    • Without skill verification, a human-in-the-loop (HITL) gate must trigger on every irreversible call, which is operationally unsustainable and degrades into formal approval at nontrivial scale.
    • Treating skill verification as a separate gated procedure means HITL is invoked only for unverified artifacts, which makes the system sustainable.
    • The authors present a portable runtime profile that includes a trust schema with an explicit verification level in every skill manifest, a capability gate whose HITL policy is determined as a function of that verification level, a biconditional correctness criterion that any candidate verification procedure must satisfy under adversarial ensemble tests, and ten normative guidelines abstracted from a working open-source reference implementation.
    AbstractPDF
  4. 178Agents / Interpretability / AutoMLarXiv:2605.03808

    Agentic-imodels: Evolving agentic interpretability tools via autoresearch

    • Existing interpretability machine learning tools are designed for human interpretation and therefore produce outputs, such as visualizations, that AI agents cannot reliably parse or use.
    • This mismatch leads to unreliable analysis, obscured reasoning, and inefficient workflows in autonomous data science systems.
    • The lack of automated, model-agnostic metrics for agent interpretability has slowed the development of AI-centered interpretability tools.
    • An agentic self-research loop repeatedly modifies Python model implementations based on prediction performance and feedback from a new LLM-scored interpretability score.
    • It introduces a new agent interpretability score that quantifies an LLM's ability to reason about a model from its string representation using 200 separate automated tests.
    • The framework optimizes models toward the joint goal of high predictive performance, measured by ranked RMSE across 65 datasets, and high agent interpretability, measured by LLM test pass rate.
    AbstractPDF
  5. 177Agents / MemoryarXiv:2604.27707

    Contextual Agentic Memory is a Memo, Not True Memory

    • Current LLM agent memory mainly relies on external lookup mechanisms, and that is often mistakenly treated as the same thing as true learning and expertise development.
    • Lookup-based agents do not generalize effectively to novel tasks that require composition, and they only accumulate information without developing internal knowledge.
    • Existing agent memory structures are vulnerable to persistent security breaches because temporary prompt injections can be stored and retrieved permanently.
    • This paper redefines memory for LLM agents by distinguishing case-based lookup, which is context engineering, from rule-based weight-encoded learning, which is theta-learning.
    • It formalizes the limitations of lookup-based memory as a theorem on the generalization gap for compositional tasks.
    • It proposes a coexistence architecture that combines fast episodic lookup with a unified channel that periodically encodes distilled experience into model weights offline.
    AbstractPDF
  6. 176Agents / Data / InfrastructurearXiv:2604.28181

    Synthetic Computers at Scale for Long-Horizon Productivity Simulation

    • Collecting long-horizon productivity trajectories from the real world at scale is difficult because of privacy concerns around sensitive user data and the complexity of heterogeneous user environments.
    • AI agents struggle with realistic long-horizon productivity tasks, such as information gathering, analysis, collaboration, and artifact production, because they lack rich user-specific context and sustained behavior.
    • Generic, toy-level workflows for agent training do not adequately reflect the context-intensive nature of real productivity tasks, which limits agent effectiveness.
    • The Synthetic Computers at Scale methodology creates diverse, artifact-rich, user-specific synthetic computer environments by instantiating sampled personas and populating digital workspaces.
    • Within this environment, it runs long-horizon productivity simulations that mimic about a month of human work, using setup agents that define goals and collaborators and task agents that handle iterative planning and daily execution.
    • It extracts rich experiential learning signals, both process-level and outcome-level, from these simulations to support agent self-improvement and reinforcement learning.
    AbstractPDF
  7. 175Agents / Reinforcement LearningarXiv:2605.02572

    On Training Large Language Models for Long-Horizon Tasks: An Empirical Study of Horizon Length

    • Large language models deployed as interactive agents struggle on multi-step, long-horizon real-world tasks.
    • Prior work has largely overlooked intrinsic task horizon length as a fundamental factor shaping LLM training dynamics, often conflating it with other complexity factors.
    • Longer horizons worsen challenges such as error accumulation, exponential growth in state-action mapping complexity, and ambiguous credit assignment caused by sparse and delayed feedback.
    • The authors perform a systematic empirical study using controlled task environments, Sudoku and Rush Hour, designed to isolate and vary intrinsic task horizon length while keeping reasoning complexity constant.
    • The study evaluates the horizon-shortening principle, specifically macro actions that let the agent produce multiple atomic actions in one step, and subgoal decomposition that splits the task into verifiable subgoals with dense intermediate rewards.
    • After supervised fine-tuning, the LLM agent is trained with reinforcement learning using a re-evaluated REINFORCE algorithm combined with off-policy stabilization techniques for robust training.
    AbstractPDF
  8. 174Agents / Multi-Agent / ArchitecturearXiv:2605.03310

    Coordination as an Architectural Layer for LLM-Based Multi-Agent Systems

    • LLM-based multi-agent systems show high failure rates in real operating environments, ranging from 41 to 87 percent, because of coordination failures such as ambiguity and misalignment.
    • There is no principled framework that maps specific coordination configurations to predictable failure signatures, which hinders proactive system design.
    • Prior empirical comparisons of multi-agent structures often conflate structural effects with increased information access, making it hard to isolate the true structural impact.
    • The paper proposes treating coordination as a composable architectural layer distinct from agent logic and information access, and it minimally specifies this layer with seven elements, including communication topology and aggregation rules.
    • It designs and implements an information-control experimental methodology that strictly fixes the LLM, tool stack, prompt templates, and output caps while varying only the coordination layer.
    • Using a prediction-market testbed, Polymarket, it evaluates and diagnoses structural effects on prediction reliability and resolution with objective real-world outcomes and rigorous proper scoring rules, including the Brier score and Murphy decomposition.
    AbstractPDF
  9. 173Agents / Coding / EvaluationarXiv:2604.25067

    Frontier Coding Agents Can Now Implement an AlphaZero Self-Play Machine Learning Pipeline For Connect Four That Performs Comparably to an External Solver

    • Existing AI capability benchmarks may fail to provide sufficiently early warning signs of recursive self-improvement (RSI).
    • There is a need to measure AI's ability to autonomously implement end-to-end machine learning pipelines based on established AI research results.
    • Evaluation of advanced AI systems is complicated by potential strategic behavior such as sandbagging or deliberate performance degradation.
    • We developed a benchmark that tasks frontier coding agents with autonomously implementing an AlphaZero-style self-play ML pipeline for Connect Four within a 3-hour time limit on consumer hardware.
    • We evaluated four frontier coding agents, Gemini 3.1 Pro, Claude Opus 4.6, Claude Opus 4.7, and GPT-5.4, in an isolated sandbox Docker environment.
    • We investigated anomalous time-budget usage patterns by running sandbagging probes on GPT-5.4 with different prompt strategies, such as Hobbyist versus RSI Alert, and different execution environments.
    AbstractPDF
  10. 172LLMs / Pretraining / SafetyarXiv:2601.21343

    Self-Improving Pretraining: using post-trained models to pretrain better models

    • Current LLM training defers the introduction of key behaviors such as safety, factuality, quality, and complex reasoning until the post-training stage.
    • Patterns learned during early pretraining lack explicit guidance for these desirable properties, which creates persistent weaknesses that are hard to fully correct later.
    • Pretraining data largely lacks explicit reasoning traces, so acquiring complex reasoning ability depends mainly on expensive post-training and limits efficiency.
    • The Self-Improving Pretraining framework redefines pretraining as a sequence generation task and uses stronger post-trained models as both a suffix rewriter that improves data quality and safety and a suffix judge that supplies training reward signals.
    • The Think-in-the-Middle stage augments pretraining data by interleaving thinking traces, applies supervised fine-tuning, and then performs reinforcement learning to optimize the usefulness of generated thoughts for subsequent text prediction.
    • It trains the policy model to generate higher-quality, safer, and more factual suffixes by using online RL algorithms such as DPO and RF-NLL with rewards supplied by the judge.
    AbstractPDF
  11. 171Agents / Multi-Agent / OrchestrationarXiv:2512.04388

    Learning to Orchestrate Agents in Natural Language with the Conductor

    • Manually designing the optimal prompt engineering strategy and multi-agent workflow for complex tasks is time-consuming and difficult.
    • Because no single model is universally optimal, it is difficult to make effective use of the specialized strengths of different LLMs.
    • Existing multi-agent coordination methods often depend on human-designed scaffolds, predefined routing, and fixed tool-use patterns, which limits flexibility and adaptability.
    • Conductor is a 7B LLM trained end to end with reinforcement learning, using the GRPO algorithm, to generate agent workflows in natural language that specify communication patterns with worker LLMs and subtasks.
    • Conductor orchestrates a diverse pool of seven strong worker LLMs, both commercial and open source, by dynamically decomposing problems and assigning target subtasks with tailored instructions.
    • The framework allows flexible communication topologies, including recursive self-calls, enabling dynamic refinement of coordination strategies and adaptive resource allocation at test time.
    AbstractPDF
  12. 170Reasoning / Agents / CodingarXiv:2605.02396

    HeavySkill: Heavy Thinking as the Inner Skill in Agentic Harness

    • The concrete mechanisms that drive performance inside complex LLM-agent orchestration frameworks remain largely unidentified.
    • Current LLM-agent designs often depend on broad systems engineering without a clear abstraction for the core reasoning process.
    • Existing test-time scaling, or TTS, strategies often require specialized structural changes or large amounts of post-training, so they lack a universal and portable skill representation.
    • The authors propose HEAVYSKILL, a two-stage reasoning pipeline consisting of parallel reasoning that generates K independent trajectories and sequential deliberation that processes and synthesizes those trajectories.
    • They implement a serialized memory cache that stores and organizes reasoning trajectories, which helps context management and avoids positional bias during deliberation.
    • They improve portability by distilling the focused thinking workflow into a readable skill document that any LLM orchestrator can execute autonomously from in-context instructions.
    AbstractPDF
  13. 169Agents / Skills / Self-ImprovementarXiv:2604.20987

    Co-Evolving LLM Decision and Skill Bank Agents for Long-Horizon Tasks

    • We build autonomous agents that can continuously improve by discovering, preserving, and reusing structured skills in complex, long-horizon environments.
    • Current LLM agents often rely on curated human datasets or extensive external feedback to acquire skills, which limits scalability and adaptability.
    • Organizing, refining, and reliably retrieving skills across diverse and future tasks remains a challenge for existing agent architectures.
    • The COS-PLAY framework introduces a multi-agent coevolution system with a decision agent (LLM) that generates trajectories and a skill-bank agent that converts them into reusable structured skills.
    • Skills are defined as reusable, temporally extended action abstractions that include protocols such as summaries, preconditions, plans, and success or abort criteria, and they are stored in a dynamically evolving skill bank.
    • The two agents are optimized with Group Relative Policy Optimization (GRPO) and their own LoRA adapters, fostering a closed-loop coevolution in which better skills improve decision making and better rollouts refine skill learning.
    AbstractPDF
  14. 168Agents / RAG / ReasoningarXiv:2604.26649

    When to Retrieve During Reasoning: Adaptive Retrieval for Large Reasoning Models

    • Large reasoning models generate long chains of multi-step thought, but they still suffer from factual errors and higher hallucination rates when they need external knowledge.
    • Traditional retrieval-augmented generation systems use a single pre-retrieval step, which fundamentally conflicts with the dynamic and unpredictable knowledge gaps that emerge during an LRM's multi-step reasoning.
    • Existing iterative retrieval methods designed for standard LLMs are not compatible with LRMs because they use the wrong granularity, depend on internal signals unavailable in black-box models, or impose excessive efficiency costs on long reasoning chains.
    • ReaLM-Retrieve, a reasoning-aware retrieval framework, formulates dynamic retrieval as a sequential decision problem and intervenes at the granularity of logical reasoning steps rather than tokens or sentences.
    • It introduces Reasoning Step Uncertainty Score (RSUS), which combines verbalized uncertainty, entity-based entropy, and consistency signals to detect knowledge gaps and retrieval needs in a black-box compatible way.
    • A retrieval intervention policy trained with REINFORCE dynamically decides when to search, constructs relevant queries, and integrates retrieved content efficiently with techniques such as implicit compression, speculative caching, and KV-cache preservation.
    AbstractPDF
  15. 167Agents / Memory / MultimodalarXiv:2604.26622

    OCR-Memory: Optical Context Retrieval for Long-Horizon Agent Memory

    • LLMs have finite context windows, which limits how much past interaction history an agent can preserve and use effectively in long-horizon tasks.
    • Existing text-based memory compression methods often lose fine-grained structural and procedural details that are critical for complex agent tasks such as debugging.
    • Text-only retrieval methods can return fragmented or semantically similar but logically unrelated information, and generative retrieval can hallucinate incorrect evidence.
    • The framework visually encodes the agent's entire interaction trajectory into a dense image and then uses an OCR model to compress it into compact visual tokens.
    • The Locate-and-Transcribe retrieval paradigm predicts specific segment indices in visually marked memory to fetch original text deterministically and reduce hallucination risk.
    • An adaptive multi-resolution strategy dynamically adjusts the visual fidelity of stored memory over time, reducing visual token cost while still allowing high-fidelity details to be recovered on demand through active recall.
    AbstractPDF
  16. 166Agents / Distillation / EfficiencyarXiv:2604.24881

    Latent Agents: A Post-Training Procedure for Internalized Multi-Agent Debate

    • Explicit multi-agent debate improves LLM accuracy and reduces hallucinations, but it is computationally expensive because it requires multiple model calls and verbose outputs.
    • Existing methods for internalizing LLM reasoning mainly focus on explicit reasoning steps in a single agent and do not handle the complex interactions of multi-agent debate.
    • Suppressing undesirable LLM behavior often leads to an alignment tax, which is a loss of general model capability caused by coarse control mechanisms.
    • We developed IMAD, a two-stage fine-tuning pipeline consisting of supervised fine-tuning (SFT) on the full multi-agent debate trajectory followed by reinforcement learning (RL) with dynamic rewards.
    • The RL stage uses a dynamic reward function that rewards correct answers while progressively reducing incentives for explicit debate language and tightening output length limits, forcing potential internalization.
    • We apply activation steering to identified agent subspaces within the internalized model to control specific behaviors, including suppression of malicious traits.
    AbstractPDF
  17. 165Agents / SkillsarXiv:2604.24026

    From Skill Text to Skill Structure: The Scheduling-Structural-Logical Representation for Agent Skills

    • Agent skills are mostly represented as text-heavy artifacts that mix the invocation interface, execution structure, and tool use inside natural-language descriptions.
    • The implicit nature of skill information makes it difficult for automated systems to parse, validate, reliably reuse, and efficiently discover relevant capabilities in large skill repositories.
    • Security risk assessment before execution is hard for third-party skills because the unstructured text format makes risk evidence difficult to inspect and audit.
    • To make skill information explicit from unstructured SKILL.md documents, we propose Scheduling-Structural-Logical (SSL), a typed three-layer JSON graph representation.
    • SSL separates skill properties into a Scheduling Layer for skill-level interfaces, a Structural Layer for scene-level execution steps, and a Logical Layer for atomic actions and resource evidence.
    • We developed an LLM-based normalizer, using DeepSeek-V3.2, that converts SKILL.md files into the SSL schema and achieves high fidelity through strict grounding on the source artifact plus validation and retries.
    AbstractPDF
  18. 164Agents / Multi-AgentarXiv:2604.22446

    From Skills to Talent: Organising Heterogeneous Agents as a Real-World Company

    • Current multi-agent systems rely on fixed team structures and tightly coupled coordination logic, which makes them inflexible and brittle for novel, open-ended projects.
    • Existing frameworks face incompatible runtimes and session-bound learning problems, which hinder continuous knowledge accumulation and interoperability across different agents.
    • The lack of a unified organizational abstraction makes it difficult to systematically manage, coordinate, and evolve an AI workforce for complex real-world tasks.
    • OneManCompany (OMC) adopts a Talent-Container architecture that integrates heterogeneous agents as employees, with portable identities and an abstraction over diverse runtime environments.
    • Project execution is formalized as Explore-Execute-Review (E2R) tree search, providing structured planning, execution, and evaluation, along with formal guarantees of termination and no deadlock.
    • OMC implements systematic self-evolution mechanisms at both the individual agent and organization level, including self-reflection, updated standard operating procedures (SOPs), and human resources performance management for continual learning.
    AbstractPDF
  19. 163Agents / Multi-Agent / EfficiencyarXiv:2604.25917

    Recursive Multi-Agent Systems

    • A single LLM often struggles on complex tasks that require broad reasoning or diverse expertise.
    • Existing multi-agent systems (MAS) rely on explicit text-based interaction, which causes high latency, increased token usage, and gradient instability when optimizing at the system level.
    • Optimizing the entire set of agents in an MAS through training is computationally expensive, while prompt-based adaptation has limited ability to improve the core capabilities of the agents.
    • The paper develops RecursiveMAS, a framework that formulates the entire multi-agent system as unified latent-space recursive computation for iterative refinement of collaborative reasoning.
    • It introduces lightweight residual RecursiveLink modules, with inner modules for within-agent communication and outer modules for between-agent communication, to enable efficient latent-state transfer and refinement among agents.
    • It implements a two-stage inner-outer loop training algorithm that freezes the base LLM parameters and optimizes only RecursiveLink, which promotes stable system-level co-optimization.
    AbstractPDF
  20. 162Agents / SurveyarXiv:2604.22748

    Agentic World Modeling: Foundations, Capabilities, Laws, and Beyond

    • World model concepts are fragmented across AI fields, so definitions and evaluation practices are inconsistent and progress is hard to compare.
    • Existing surveys of world models usually lack a coherent capability progression across modalities and domains, or a precise framework for analyzing large generative models as simulators.
    • The role of world modeling in emerging agentic AI applications, such as web agents and multi-agent systems, is often underrepresented in unified frameworks.
    • The paper introduces a comprehensive level-by-law taxonomy that organizes world-modeling capability into three levels, L1 Predictor, L2 Simulator, and L3 Evolver, and four dominant law domains, physical, digital, social, and scientific.
    • It defines clear and verifiable boundary conditions for moving from one level to the next, including long-horizon consistency and intervention sensitivity for L2 and evidence-based diagnosis for L3.
    • It proposes a shift toward decision-centered evaluation metrics, such as Action Success Rate and Counterfactual Outcome Deviation, and standardizes evaluation protocols according to the defined capability levels.
    AbstractPDF
  21. 161LLMs / Agents / EfficiencyarXiv:2604.21590

    AgenticQwen: Training Small Agentic Language Models with Dual Data Flywheels for Industrial-Scale Tool Use

    • Industrial deployment of LLM-based agents is constrained by the high compute cost and latency associated with very large or proprietary foundation models.
    • There is a lack of small language models that are specialized and optimized for robust multi-step agent capabilities and tool interaction.
    • Static synthetic datasets used for agent reinforcement learning often cause data homogeneity and rapid saturation of the learning signal, limiting further gains.
    • The paper trains small AgenticQwen models, including 8B and 30B-A3B variants, with a multi-round reinforcement learning approach that combines Reasoning RL and Agentic RL.
    • It introduces a dual data flywheel mechanism, composed of a Reasoning Data Flywheel and an Agentic Data Flywheel, to iteratively generate increasingly complex and diverse training data.
    • A strong LLM, Qwen3-235B, is used to create a fully simulated training environment that models both the user and the tools, removing dependence on external proprietary APIs for data synthesis and simulation.
    AbstractPDF
  22. 160Agents / InfrastructurearXiv:2604.25850

    Agentic Harness Engineering: Observability-Driven Automatic Evolution of Coding-Agent Harnesses

    • Manually designing and optimizing coding-agent harnesses, including system prompts, tools, and middleware, is time-consuming and difficult to keep up with the rapid pace of LLM progress.
    • Existing automatic optimization methods mostly tune individual harness components and therefore fail to evolve the interacting components together.
    • Heterogeneous action spaces, the difficulty of extracting executable signals from long agent trajectories, and complex attribution of edit effects make automated co-evolution of harnesses difficult.
    • AHE introduces an evolution agent that keeps the base LLM fixed while continuously optimizing every editable harness component inside a closed loop.
    • It uses the component-observability axis of the NexAU harness backbone to separate seven component types into explicit file-level elements, creating a localized action space.
    • It implements experience observability with an Agent Debugger that converts raw agent trajectories into a structured corpus of executable evidence, and decision observability with an Evolve Agent that generates evidence-based edits and records them in versioned change manifests.
    AbstractPDF
  23. 159Theory / Deep LearningarXiv:2604.21691

    There Will Be a Scientific Theory of Deep Learning

    • Traditional deep learning theory struggles to explain the complex, nonconvex, and overparameterized behavior seen in modern neural networks.
    • Current deep learning system design and optimization practices often rely on empirical trial and error rather than a principled scientific foundation.
    • A fundamental scientific understanding is needed to describe, characterize, and control increasingly powerful AI systems in terms of safety and interpretability.
    • The paper proposes a scientific theory of learning dynamics for deep learning that aims to characterize the fundamental properties of neural networks and their training processes through first-principles computation.
    • It advocates a scientific methodology for deep learning theory that emphasizes empirical observation, falsifiable predictions, and the search for simple, unifying principles.
    • It synthesizes and reinterprets prior work across five categories, such as analytically solvable settings, insightful limits, and empirical laws, as evidence for the theory's feasibility and emergence.
    AbstractPDF
  24. 158Agents / Multi-Agent / SafetyarXiv:2604.18005

    Diversity Collapse in Multi-Agent LLM Systems: Structural Coupling and Collective Failure in Open-Ended Idea Generation

    • The assumption that multi-agent LLM systems inherently broaden idea diversity on complex creative tasks has been only weakly validated.
    • When the underlying LLMs are homogeneous, different roles in a MAS often amplify shared pretraining biases rather than introducing true novelty, leading to computational inefficiency and early convergence.
    • A lack of idea diversity in exploratory domains can trap users in narrow solution spaces, create overconfidence in suboptimal answers, and suppress unconventional hypotheses.
    • We conducted a systematic empirical study using scientific research proposal generation as the task and evaluated diversity at three levels: model intelligence, agent cognition, and system dynamics.
    • We developed a general three-stage multi-agent ideation pipeline consisting of role instantiation, iterative deliberation using a specified topology, and proposal synthesis by an editor agent.
    • We quantified diversity with four complementary metrics, such as Vendi Score and Semantic Dispersion, and explored solutions by varying agent personas, group size, and communication topologies such as Nominal Group Technique (NGT) and Subgroups.
    AbstractPDF
  25. 157Agents / RAG / Multi-AgentarXiv:2604.18509

    MASS-RAG: Multi-Agent Synthesis Retrieval-Augmented Generation

    • Large language models (LLMs) often generate factually unreliable or hallucinated outputs because they rely on static parametric knowledge.
    • Traditional retrieval-augmented generation (RAG) struggles with noisy, incomplete, or irrelevant retrieval context, which degrades generation quality.
    • Existing multi-agent RAG frameworks often use a single judging agent for filtering, which limits their ability to identify and exploit diverse, complementary evidence distributed across documents.
    • We introduce MASS-RAG, a training-free multi-agent synthesis framework with specialized LLM agents for evidence refinement, selective candidate-answer generation, and final-answer synthesis.
    • It uses three distinct filter agents, Summarizer, Extractor, and Reasoner, each of which processes retrieved documents from a unique and complementary perspective to refine query-relevant evidence.
    • It uses a selective Answer Agent that independently generates candidate answers from each filtered response, and a Synthesis Agent that combines those candidates or the filtered evidence into a unified final answer.
    AbstractPDF
  26. 156Agents / Memory / ArchitecturearXiv:2604.20158

    Stateless Decision Memory for Enterprise AI Agents

    • There is a gap between the sophisticated stateful memory structures used in academic LLM agent research and the simpler retrieval-augmented generation (RAG) pipelines widely used in enterprise deployment.
    • Enterprise AI agents in regulated domains such as finance and healthcare require core system properties such as deterministic reproducibility, auditable provenance, multi-tenant isolation, and horizontal scalability.
    • Existing stateful memory structures often violate these enterprise requirements because they rely on evolving internal representations and path-dependent updates.
    • The paper proposes Deterministic Projection Memory (DPM), which consists of an append-only event log and a task-conditional projection mechanism.
    • The append-only event log stores raw events, such as document chunks and tool outputs, in arrival order and serves as a single persistent source of truth.
    • At decision time, a stateless projection component implemented as a single temperature-zero LLM call generates a structured memory view, such as facts, reasoning, and compliance notes, from the full event log and task specification, constrained by a fixed memory budget.
    AbstractPDF
  27. 155Agents / EDA / Code GenerationarXiv:2604.15082

    Autonomous Evolution of EDA Tools: Multi-Agent Self-Evolved ABC

    • The development of electronic design automation (EDA) tools is labor-intensive and constrained by the complexity of heuristic design, interactions among algorithms, and the reengineering effort required for large codebases such as ABC.
    • ABC, the de facto standard for logic synthesis, is difficult to evolve because its monolithic 1.2-million-line C codebase, deep interdependencies, and static heuristics make it hard to integrate new research.
    • Existing LLM-based code evolution frameworks were limited to isolated functions or smaller repositories of tens of thousands of lines, and could not handle the scale and multi-objective optimization of full EDA tools.
    • The self-evolution framework integrates multi-agent LLMs (Claude Sonnet 4.5) with domain expertise and uses a pre-evolution knowledge bootstrapping stage that teaches the structure of ABC and the related literature.
    • The multi-agent structure assigns specialized LLM agents, Flow, Mapper, Logic Minimization, and Planning, to distinct subsystems of the ABC codebase, enabling collaborative and localized code evolution.
    • The evolutionary iterative workflow includes code generation, compilation, formal equivalence checking (CEC) for correctness, distributed benchmark evaluation, and QoR feedback to refine the tool.
    AbstractPDF
  28. 154Agents / Web / ReasoningarXiv:2604.18131

    Training LLM Agents for Spontaneous, Reward-Free Self-Evolution via World Knowledge Exploration

    • Existing self-evolving LLM agents depend heavily on external human supervision, such as predefined tasks, workflows, or validated reward signals.
    • Unlike humans, whose exploration is driven by curiosity, agents lack the ability to learn spontaneously and autonomously in new environments without explicit instructions or rewards.
    • Current paradigms often shift the engineering burden into complex agent orchestration instead of enabling genuine workflow-free, reward-free self-evolution.
    • The authors introduce Native Evolution, a decoupled agent life cycle in which the agent autonomously explores the environment at inference time without tasks or rewards and summarizes the experience into structured World Knowledge, or K.
    • They develop an outcome-based reward function used only during training that measures the usefulness of the generated K by performance on potential downstream tasks.
    • They use a two-stage training framework that first applies supervised fine-tuning to internalize meta-evolutionary behavior and then applies reinforcement-based rejection sampling to optimize exploration and information-management strategies.
    AbstractPDF
  29. 153Agents / RAG / SkillsarXiv:2604.15771

    Skill-RAG: Failure-State-Aware Retrieval Augmentation via Hidden-State Probing and Skill Routing

    • Existing retrieval-augmented generation systems often diagnose post-retrieval failure poorly and respond with generic retries instead of addressing the root cause.
    • Persistent retrieval failures often arise from a structural mismatch between the user query and the available evidence, such as broad queries or multi-hop questions, which cannot be fixed by repeated retrieval alone.
    • Traditional adaptive RAG approaches lack fine-grained, failure-conditioned control and cannot distinguish different types of retrieval mismatch or the model's internal failure state.
    • Skill-RAG uses a recurrent pipeline with a hidden-state prober that detects whether the LLM is in a failure state based on its internal representation after retrieval.
    • When failure is detected, a prompt-based skill router diagnoses the specific cause of the query-evidence mismatch and selects one of four predefined target retrieval skills, such as query rewriting, question decomposition, or evidence focusing.
    • The selected skill performs corrective actions such as restructuring the query and triggering a new retrieval round, and the loop continues until the prober indicates sufficiency, a termination skill is chosen, or the maximum number of rounds is reached.
    AbstractPDF
  30. 152LLMs / Architecture / DistillationarXiv:2604.14191

    Attention to Mamba: A Recipe for Cross-Architecture Distillation

    • Transformer models are powerful, but they incur quadratic compute cost as sequence length grows, which limits efficiency on long sequences and inference.
    • Alternative linear architectures, including state-space models such as Mamba, offer efficiency but often underperform Transformers on downstream tasks at scale.
    • Previous attempts at cross-architecture distillation from Transformers to Mamba-like structures struggled to preserve performance and often required hybrid attention-SSM solutions.
    • The paper develops a principled two-stage distillation recipe that transfers first from Softmax Attention to Linear Attention (Hedgehog), and then from Linear Attention to adapted Mamba (HedgeMamba).
    • The Mamba SSM mixer parameters are initialized using the feature maps learned in the Linear Attention stage, and additional Mamba components are set to act as identity operators.
    • The full HedgeMamba structure is then fine-tuned with standard cross-entropy loss on the answers, activating all Mamba components.
    AbstractPDF
  31. 151Agents / Self-ImprovementarXiv:2604.15034

    Autogenesis: A Self-Evolving Agent Protocol

    • Recent advances in LLM-based agent systems have shown promise for handling complex long-horizon tasks.
    • However, existing agent protocols, such as A2A and MCP, do not adequately specify entity lifecycle and context management, version tracking, or evolution-safe update interfaces, which encourages monolithic designs and fragile glue code.
    • The paper introduces Autogenesis Protocol (AGP), a self-evolving protocol that separates what evolves from how evolution happens.
    • Its Resource Substrate Protocol Layer (RSPL) models prompts, agents, tools, environments, and memory as protocol-native resources with explicit state, lifecycle, and versioned interfaces.
    • Its Self Evolution Protocol Layer (SEPL) specifies closed-loop operator interfaces for proposing, evaluating, and confirming improvements, with auditable lineage and rollback.
    • Building on AGP, the paper presents Autogenesis System (AGS), a self-evolving multi-agent system that dynamically instantiates, retrieves, and refines protocol-native resources at runtime.
    AbstractPDF
  32. 150Agents / Safety / EvaluationarXiv:2604.08567

    Multi-User Large Language Model Agents

    • Large language models and their agents are optimized mainly for single-actor interaction scenarios, which overlooks distinct user identities, roles, and potentially conflicting goals.
    • Existing LLM agent systems lack native protocols for distinguishing user roles, enforcing information boundaries, or resolving conflicts among multiple users' interests.
    • Current models struggle to manage the heterogeneous utility, different permission levels, information asymmetry, and privacy constraints embedded in realistic team workflows and organizational tools.
    • The authors formalize multi-user LLM interaction as a multi-actor decision problem in which a single agent optimizes a weighted social objective while accounting for each user's utility, permissions, and access-control policy.
    • They establish a unified interaction protocol that defines user personas with explicit permissions and private context, along with agent mechanisms that observe shared context and provide personalized updates.
    • To empirically evaluate modern LLMs on multi-actor tasks, they design a suite of three stress-test scenarios: multi-user instruction following, user-to-user access control, and multi-user meeting coordination.
    AbstractPDF
  33. 149Agents / Web / SkillsarXiv:2604.13318

    WebXSkill: Skill Learning for Autonomous Web Agents

    • Autonomous web agents struggle with long-horizon, multi-page workflows because they do not effectively retain and reuse procedural knowledge.
    • Existing skill formulations suffer from a grounding gap, where skills are either interpretable but not executable, or executable but opaque to the agent.
    • Prior skill-learning methods often require high acquisition cost or lack context-aware retrieval, which limits scalability and efficiency.
    • WEBXSKILL proposes a new executable skill that combines parameterized action programs with step-level natural-language guidance, which supports both direct execution and agent interpretation.
    • It implements a three-stage pipeline for skill management: extraction from synthetic trajectories, organization into a URL-based skill graph, and deployment through grounded or guided modes.
    • The framework uses LLM-based abstraction for skill generalization and a curation process that includes online deduplication and executability checks to build a robust skill library.
    AbstractPDF
  34. 148Agents / Coding / ProductionarXiv:2604.12108

    LLM-Based Automated Diagnosis Of Integration Test Failures At Google

    • Diagnosing integration test failures is highly time-consuming, often taking hours or days, and imposes a substantial cognitive burden on developers.
    • Modern distributed systems produce huge volumes of logs, averaging 11,058 lines across 26 files per failure from many distributed, dynamically named sources, which makes manual inspection difficult.
    • Logs are often semi-structured and heterogeneous, with a low signal-to-noise ratio, so many warnings and errors unrelated to the real root cause obscure the key information.
    • The authors implemented Auto-Diagnose, an LLM-centered automation pipeline that collects and aggregates logs from the test driver and system under test (SUT) components when an integration test fails.
    • It uses Gemini 2.5 Flash together with carefully designed prompt templates that include step-by-step guided reasoning, strict negative constraints to prevent guessing, and a precise output format for diagnosis.
    • The LLM output is post-processed into readable Markdown and the identified relevant log lines are made clickable, integrating diagnosis directly into Google's internal code review system, Critique, for a smooth developer workflow.
    AbstractPDF
  35. 147Agents / MemoryarXiv:2604.14004

    Memory Transfer Learning: How Memories are Transferred Across Domains in Coding Agents

    • Existing self-evolving AI agents for coding tasks usually restrict memory use to homogeneous task domains and overlook the shared infrastructural substrate, such as programming languages and runtime environments.
    • This limitation prevents agents from leveraging transferable knowledge across diverse real-world coding problems, which hurts generalization and robust performance.
    • Prior work lacked a systematic study of how memory transfers across domains and of the design principles for effective memory in these heterogeneous settings.
    • The paper develops Memory Transfer Learning, a two-stage process consisting of offline memory generation from agent reasoning trajectories and online memory retrieval while solving new tasks.
    • Using an LLM for generation, it creates four distinct memory representations, Trajectory, Workflow, Summary, and Insight, spanning low-level task details through high-level generalized meta-knowledge.
    • It retrieves the most relevant memory from heterogeneous domain memory pools using embedding-based cosine similarity and supplies it to the coding agent's system prompt.
    AbstractPDF
  36. 146LLMs / ArchitecturearXiv:2604.12374

    Nemotron 3 Super: Open, Efficient Mixture-of-Experts Hybrid Mamba-Transformer Model for Agentic Reasoning

    • Existing large language models struggle with reasoning efficiency and real-world deployment cost, and earlier Mixture-of-Experts (MoE) designs often ignored real latency and memory-bandwidth constraints.
    • Scaling large language model pretraining to trillions of tokens while preserving stability and accuracy in low-precision formats remains unsolved, and it hinders energy efficiency and hardware friendliness.
    • Developing robust and generalizable agentic reasoning capabilities in LLMs for multi-stage tool use and long-horizon tasks requires both specialized architectural and training approaches.
    • The paper introduces a hybrid Mamba-attention Mixture-of-Experts (MoE) architecture with a new LatentMoE design for efficient routing and a Multi-Token Prediction (MTP) mechanism that improves modeling quality and speculative decoding.
    • It performs large-scale pretraining on 25 trillion tokens using NVIDIA's proprietary low-precision NVFP4 format, demonstrating stability and accuracy at scale.
    • It implements a multi-stage post-training pipeline that combines extensive supervised fine-tuning (SFT) with multi-environment reinforcement learning from verifiable rewards (RLVR), with a focus on agentic reasoning and long-context capability up to 1M tokens.
    AbstractPDF
  37. 145Agents / Evaluation / CodingarXiv:2604.12162

    AlphaEval: Evaluating Agents in Production

    • There is a substantial research-to-production gap in AI agent evaluation because current benchmarks do not reflect the complexity of real-world commercial deployment.
    • Traditional benchmarks rely on explicitly defined requirements, deterministic metrics, and static tasks, which contrasts with operational settings characterized by implicit constraints, subjective judgment, and changing demands.
    • Evaluation often focuses on the base language model and overlooks the substantial effect of the full agent product or scaffold on real-world performance.
    • The authors introduced AlphaEval, a benchmark with 94 tasks collected from seven companies across six O*NET job zones and derived from active commercial deployments.
    • They implemented a four-stage requirements-to-benchmark construction framework that turns authentic, under-specified operational requirements into executable and automated evaluation tasks.
    • They integrated a pluralistic evaluation methodology, such as reference answers, formal logic, rubric-based scoring, and execution-based scoring, with LLM-as-a-Judge and task-specific economic-value annotations.
    AbstractPDF
  38. 144Agents / ResearcharXiv:2604.13018

    Toward Autonomous Long-Horizon Engineering for ML Research

    • Current autonomous AI systems struggle with long-horizon tasks that take hours to days and require sustained, coherent progress across multiple stages.
    • Machine learning research papers are often underspecified, forcing agents to infer missing implementation details and manage complex environment setup.
    • Interpreting delayed and noisy experimental feedback and maintaining project state continuity across iteration cycles pose major challenges.
    • AiScientist implements thin control over thick state, where the top-level Orchestrator uses concise summaries and detailed project information lives in a permission-scoped shared workspace.
    • It uses a File-as-Bus protocol for artifact-mediated coordination and leverages the structured organization of the shared workspace to preserve persistent state and cumulative progress.
    • Its hierarchical orchestration model lets the Orchestrator delegate tasks to Tier-1 specialist agents exposed as callable tools, such as paper-understanding, implementation, and experimentation experts.
    AbstractPDF
  39. 143Reasoning / EfficiencyarXiv:2604.03679

    LightThinker++: From Reasoning Compression to Memory Management

    • LLMs generate many tokens, and the quadratic complexity of attention together with the linear growth of the KV cache creates substantial compute and memory overhead for complex reasoning.
    • Existing context management techniques such as prompt engineering and real-time token pruning often require extensive data construction or introduce significant inference latency.
    • Implicit compression methods are efficient, but they risk irreversible information loss that can create a logical bottleneck in complex reasoning tasks that require detailed intermediate steps.
    • The initial framework, LightThinker, trains the LLM to implicitly compress long reasoning traces into concise semantic representations using special gist tokens and split attention masks.
    • LightThinker++ extends this with explicit, action-level memory management through primitives such as commit, expand, and fold, enabling dynamic preservation of semantic summaries and restoration of raw reasoning detail.
    • It uses a specialized environment-aware trajectory synthesis pipeline to train the model with purposeful memory scheduling and generate expert demonstrations that interleave reasoning with explicit memory operations.
    AbstractPDF
  40. 142Multimodal / MedicalarXiv:2604.05081

    MedGemma 1.5 Technical Report

    • We introduce MedGemma 1.5 4B, the latest model in the MedGemma collection.
    • MedGemma 1.5 extends MedGemma 1 by integrating additional capabilities: high-dimensional medical imaging, including CT and MRI volumes and whole-slide histopathology images; anatomical localization with bounding boxes; multi-view chest X-ray analysis; and improved medical document understanding, including lab reports and electronic health records.
    • The report details the innovations needed to enable these modalities within a single architecture, including new training data, long-context 3D volume slicing, and whole-slide pathology sampling.
    • Compared with MedGemma 1 4B, MedGemma 1.5 4B shows substantial gains on these new domains, improving 3D MRI state classification accuracy by 11% and 3D CT state classification by 3% in absolute terms.
    • On whole-slide pathology images, MedGemma 1.5 4B improves macro F1 by 47%.
    • It also improves anatomical localization in chest X-rays by increasing Intersection over Union by 35%, and it achieves 4% macro accuracy on longitudinal chest X-ray analysis.
    AbstractPDF
  41. 141Agents / SkillsarXiv:2604.04323

    How Well Do Agentic Skills Work in the Wild: Benchmarking LLM Skill Usage in Realistic Settings

    • Existing LLM agent skill benchmarks often rely on idealized conditions, where preselected, hand-crafted skills are provided directly to the agent.
    • In real-world scenarios, agents face challenges such as independently selecting relevant skills from many options, retrieving skills from large and uncurated repositories, and adapting general skills to specific queries.
    • The true utility and limits of agent skills under practical, non-ideal conditions have remained largely unquantified.
    • The authors built a large dataset of 34,198 real-world skills to simulate realistic retrieval and adaptation conditions for LLM agents.
    • They developed a skill retrieval engine and evaluated different retrieval strategies, including keyword, semantic, hybrid, and agentic retrieval, to identify effective skill discovery methods.
    • They evaluate LLM agent performance across six progressively more realistic settings on SKILLSBENCH and TERMINAL-BENCH 2.0, introducing the challenges of selection, retrieval, and adaptation.
    AbstractPDF
  42. 140Agents / CodingarXiv:2604.05013

    Scaling Coding Agents via Atomic Skills

    • [Withdrawn paper] The latest arXiv version, v2, states that Yue Liu has withdrawn this paper; this version was posted on 24 April 2026.
    • The stated reason is that significant data errors discovered after submission affect the validity of the results; the author says a corrected version may be submitted later.
    • Official reason: We request standard withdrawal of this submission because significant errors were discovered in the data after submission, which affect the validity of the results. We may submit a corrected version later
    • Previously described methods and performance figures were pre-withdrawal claims and are not presented as valid research findings or grounds for recommending adoption.
    • Official withdrawal notice and version history: https://arxiv.org/abs/2604.05013 .
    AbstractPDF
  43. 139Agents / EvaluationarXiv:2604.06240

    The Art of Building Verifiers for Computer Use Agents

    • Reliable verification of task success for Computer Use Agents is difficult because trajectories are long, visually rich, and ambiguous.
    • Human annotation of CUA trajectories is tedious and expensive, and it often misses subtle or transient failures.
    • Existing automatic verification systems have high false-positive rates because they struggle with token limits, context management, and correctly attributing success or failure in complex environments.
    • It introduces Universal Verifier (UV), an evaluation system for CUA trajectories based on four principles of robust verification.
    • It uses carefully designed non-overlapping rubrics and two-pass grading to detect hallucinations, and it separates evaluation into process rewards and binary outcome labels.
    • UV distinguishes controllable agent failures from uncontrollable environmental factors and uses a divide-and-conquer strategy for multimodal context management with screenshot evidence.
    AbstractPDF
  44. 138Agents / Multi-AgentarXiv:2604.02460

    Single-Agent LLMs Outperform Multi-Agent Systems on Multi-Hop Reasoning Under Equal Thinking Token Budgets

    • It is unclear whether the performance gains in multi-agent LLM systems are due to structural advantages or simply to higher test-time compute.
    • Prior comparisons between MAS and single-agent systems are often confounded by unequal token usage, which makes direct comparisons unreliable.
    • A robust evaluation method that strictly controls thought-token budgets is needed to clarify the source of the gains.
    • They introduce a theoretical framework based on the Data Processing Inequality to argue for the information efficiency of single-agent systems under a fixed reasoning budget.
    • They extensively evaluate a range of single-agent and multi-agent architectures, including Sequential, Debate, and Ensemble, across three LLM families, Qwen3, DeepSeek, and Gemini, on the multi-hop reasoning tasks FRAMES and MuSiQue.
    • They enforce strict control of the thought-token budget, meaning intermediate reasoning tokens excluding the prompt and final answer, to ensure fair comparisons across systems.
    AbstractPDF
  45. 137Agents / MemoryarXiv:2604.04503

    Memory Intelligence Agent

    • Existing memory systems for Deep Research Agents primarily rely on long-context memory, which leads to attention dilution, noise injection, and high storage and compute costs.
    • Most existing memory systems capture knowledge-oriented memory, or what, but fail to use process-oriented memory and conceptual knowledge, or how, which are central for guiding future planning in deep research.
    • The poor planning and execution of DRA come from the fact that, when memory is used only for few-shot Chain-of-Thought (CoT), the planner lacks task-specific learning and the executor misreads instructions.
    • MIA proposes a Manager-Planner-Executor architecture that separates nonparametric memory storage of past search trajectories from parametric planning and execution, and it uses a hybrid retrieval strategy.
    • A two-stage alternating reinforcement learning (RL) strategy promotes synergistic co-evolution between the Planner and the Executor, ensuring alignment between high-level planning and effective low-level task execution.
    • Test-Time Learning (TTL) and a new unsupervised evaluation framework enable continuous self-evolution, allowing the agent to refine both nonparametric and parametric memory online without explicit supervision.
    AbstractPDF
  46. 136LLMs / ArchitecturearXiv:2604.06425

    Neural Computers

    • Traditional computers, AI agents, and world models often split computation, memory, and input-output into separate hardware or software modules, or into external execution environments.
    • Existing systems depend on explicit, human-designed instruction sets, which can become rigid in domains that require high-dimensional, statistical, and globally coupled processing.
    • Existing AI agents usually mediate an external execution environment rather than internalizing the executable state into the computer itself.
    • This paper proposes Neural Computer (NC), in which the neural network itself acts as an active computer by internalizing computation, memory, and input-output within a latent runtime state.
    • NC is implemented as a video model that can roll out screen frames based on commands and user actions, and it is trained directly on input-output traces from command-line interface (CLI) and graphical user interface (GUI) environments.
    • The method includes using a diffusion transformer, a VAE, and specialized techniques for action injection and cursor supervision to develop interface-specific prototypes called NC-CLIGen and NC-GUIWorld.
    AbstractPDF
  47. 135Multi-Agent / TheoryarXiv:2603.26993

    On the Reliability Limits of LLM-Based Multi-Agent Planning

    • It models agents, messages, private tool signals, end actions, and optional human escalation within a single Bayesian risk framework rather than as role names such as planner or critic.
    • It proves an upper bound on reliability: when there is no new exogenous information, additional agent steps can only transform or compress shared evidence, not beat a centralized Bayesian decision-maker who has that evidence.
    • It characterizes inter-agent prose as a lossy communication channel. The relevant design metric is posterior distortion, not the number of agents, the number of rounds, or transcript length.
    • The experiments show a large relay penalty. gpt-4.1-mini drops from 90.7 percent single-agent accuracy to 41.2 percent with two relay agents, 43.5 percent with three, and 22.5 percent with five, while posterior-vector communication reaches 75.2 percent versus 58.1 percent for prose on a matched subset.
    • Tool use matters only when it changes the information structure. Wikipedia access is mostly redundant on MMLU, but synthetic KB lookups raise accuracy from 24.3 percent without tools to 82.7 percent.
    AbstractPDF
  48. 134LLMs / EconomicsarXiv:2603.23971

    The Price Reversal Phenomenon: When Cheaper Reasoning Models End Up Costing More

    • The method defines real cost as the sum of input-token and output-token costs, includes thinking tokens in billable output, and compares rankings based on list price with rankings based on measured total cost.
    • They audited eight RLMs, including GPT-5.2, Gemini 3 Flash/Pro, Claude Opus/Haiku, Kimi, and MiniMax variants, across 9 datasets and 11,872 queries, using prices from February and March 2026.
    • Among 252 pairwise comparisons, 21.8% showed price reversal. Gemini 3 Flash is 78% cheaper than GPT-5.2 on the published price, but 22% more expensive in total cost, and in a cited extreme case it cost 28 times more than Claude Haiku 4.5 on MMLUPro.
    • RLM procurement should benchmark real workloads and disclose per-request prompt, reasoning, and final-generation cost breakdowns, because even semantic or length-based predictors face stochastic variation in thinking tokens.
    AbstractPDF
  49. 133Multi-AgentarXiv:2603.28990

    Self-Organizing LLM Agents

    • Methodologically, the study formalizes agent organization as a dynamic system with roles, interaction phases, memory, impact, and stochastic LLM behavior, and then compares eight coordination protocols under the same task and evaluation pipeline.
    • The core idea is that sequential coordination gives only order and visibility into previous outputs, which allows agents to create task-specific roles without fixed role prompts, skip low-value participation, and form shallow hierarchies.
    • As a result, on complex tasks sequential coordination reaches much higher quality than fully shared or fully autonomous coordination and exceeds a centralized coordinator by 14%. Quality remains stable up to 256 agents, and 8 agents generate 5,006 distinct role names.
    • The limitation and the takeaway are that self-organization is bounded by capability. Strong models benefit, while weak models may degrade, so the practical prescription is not to remove all structure but to use a minimal scaffold with models that can perform meta-reasoning.
    AbstractPDF
  50. 132Code Agents / Long ContextarXiv:2603.20432

    Coding Agents are Effective Long-Context Processors

    • The method is to represent long documents and large corpora as navigable files and directories, then let the coding agent choose executable operations such as grep, sed, Python aggregation, and note files.
    • The core idea is that long-context reasoning becomes environment interaction, so the model no longer needs to compress everything into latent attention or a single retrieved snippet.
    • As a result, it reports an average improvement of 17.3 percent over the previous best published system, achieves SOTA on four of five benchmarks, and shows strong scaling from 188K-token context to a 3-trillion-token Wikipedia corpus.
    • The limitation and implication are that this approach depends on the agent's tool capabilities and on data organization, and that naive retriever addition can suppress useful exploration, so future systems need retrieval that complements rather than replaces filesystem search.
    AbstractPDF