HDATF
English
Start a conversation
Menu

Paper Archive

Every archived paper with its summary, highest number first.

Papers 1,193Archive updated BenchmarksRSS feed
  1. 194Machine LearningarXiv:2605.19269

    CODA: Rewriting Transformer Blocks as GEMM-Epilogue Programs

    • It maintains local state for operations such as the online log-sum-exp used in cross-entropy loss.
    • It recovers a substantial portion of GPU time that would otherwise be lost to data movement.
    • It provides a structured DSL that simplifies writing high-performance kernels.
    AbstractPDF
  2. 193LLMs / NLParXiv:2605.18747

    Code as Agent Harness

    • For semantic verification, code can easily be checked through tests for syntax and basic correctness, but it is still hard to verify whether the code actually satisfies the user's higher-level intent.
    • Transactional state management ensures that multi-agent systems can handle complex, concurrent edits to a shared codebase without causing merge conflicts or inconsistent state.
    • Human supervision is about developing an interface that lets humans inspect and intervene on the agents' internal code outputs without breaking the automation loop.
    AbstractPDF
  3. 192Machine LearningarXiv:2605.19407

    A Bitter Lesson for Data Filtering

    • Use a fixed number of epochs and train for four epochs.
    • Simplify the pipeline. Instead of spending thousands of GPU hours and a lot of human engineering effort on complex classifiers and heuristic rules, simply increasing training time on raw parsed web data can yield better returns.
    • Even trash has value. Robustness to mixed and random data suggests that, if the model is large enough, almost any data containing some statistical signal related to the target distribution can be useful.
    AbstractPDF
  4. 191AI / GeneralarXiv:2605.19943

    Probabilistic Tiny Recursive Model

    • Although powerful, deterministic recursion can converge to suboptimal solutions without any escape mechanism.
    • A common workaround combines test-time task-specific input perturbation with answer aggregation through voting.
    AbstractPDF
  5. 190AI / GeneralarXiv:2605.19376

    Generative Recursive Reasoning

    • Majority voting selects the most common answer among a set of samples.
    • Stochasticity shows that the probabilistic nature of latent states is a powerful tool for structured reasoning and overcomes determinism by preventing models from getting stuck in suboptimal deterministic trajectories.
    • Width-based scaling introduces a way to expand reasoning performance by increasing the number of parallel samples, or width, instead of simply increasing sequence length or model size.
    AbstractPDF
  6. 189AI Research AgentsarXiv:2605.20025

    AutoResearchClaw

    • It uses multi-agent debate for better hypothesis formation and result analysis.
    • It supports self-healing execution that can pivot or improve when experiments fail.
    • It provides verifiable reporting to avoid fabricated numbers and hallucinated citations.
    • It offers human-in-the-loop control with seven intervention modes.
    • It includes inter-run memory that turns past mistakes into future safeguards.
    AbstractPDF
  7. 188LLMs / Pretraining / EfficiencyarXiv:2605.06546

    Efficient Pre-Training with Token Superposition

    • Pretraining large language models is often extremely expensive and inefficient at scale, and it usually requires complex and invasive modifications to achieve high data throughput.
    • The paper presents Token Superposition Training, or TST, a simple drop-in method that greatly improves data throughput per FLOP during pretraining without changing parallelism, optimizers, tokenizers, data, or model architecture.
    • TST has two stages: a highly efficient superposition stage that combines many consecutive tokens into one bundle and trains with a multi-hot cross-entropy, or MCE, objective, followed by a recovery stage that returns to standard training.
    • The authors evaluate TST extensively at the 270M and 600M parameter scales and validate it on 3B and 10B A1B mixture-of-experts models, which demonstrates strong robustness across settings.
    • Ultimately, TST consistently outperforms baseline loss and downstream evaluation and reduces the total pretraining time of the 10B A1B scale by up to 2.5 times at matched loss.
    AbstractPDF
  8. 187Agents / Memory / Multi-AgentarXiv:2605.08060

    The Memory Curse: How Expanded Recall Erodes Cooperative Intent in LLM Agents

    • The problem is to reconcile the classical game-theoretic prediction that longer memory promotes cooperation with behavioral psychology findings that excessive human memory can undermine cooperation.
    • There has been no systematic large-scale study of how changes in interaction-history length affect cooperation in LLM multi-agent social dilemmas.
    • Prior LLM agent studies often used short interaction horizons, which may have missed the long-term effects of accumulated history on cooperative intent.
    • We performed extensive experiments over 500 rounds in four repeated social dilemma games with seven LLMs, systematically varying the accessible memory length from 0 to 80 rounds.
    • We analyzed more than 378,000 chain-of-thought reasoning traces with lexical analysis to quantify strategic intent, from future-oriented thinking to paranoia.
    • We performed targeted fine-tuning, memory purification, and asymmetric-memory experiments to causally identify the mechanism and develop mitigation strategies.
    AbstractPDF
  9. 186Agents / Self-Improvement / ReasoningarXiv:2605.13821

    Harnessing Agentic Evolution

    • Existing agentic evolution methods, whether procedural or agent-based, struggle with long-horizon search and often get stuck in local optima or suffer from context drift.
    • Procedural evolution is rigid because it relies on fixed rules that do not adapt when the characteristics of the search space change, which limits continuous improvement.
    • There is no stable and systematic mechanism for organizing accumulated evidence, such as candidates, feedback, and failures, and then using it to modify the evolution mechanism itself.
    • The paper formalizes agentic evolution as an interactive environment in which the accumulated history of all candidates, feedback, traces, and costs forms an observable process-level state.
    • It introduces AEVO, a controlled meta-editing framework in which an external meta-agent observes this process-level state and generates 'meta-actions'.
    • These meta-actions do not directly generate new candidates; instead, they strategically edit the mechanisms that control how future evolution proceeds, such as procedural rules or the agent operating context.
    AbstractPDF
  10. 185Agents / Science / MatharXiv:2605.06651

    AI co-mathematician: Accelerating mathematicians with agentic AI

    • Mathematical research is a complex, iterative process that requires broad exploration, intuition building, and continuous revision beyond formal proof.
    • Existing AI tools for mathematics are specialized, such as automated theorem provers or discovery engines, but they lack an integrated, stateful system that can coordinate these capabilities for long-term collaborative workflows.
    • Mathematicians currently have to manually integrate multiple AI tools and computation resources across different aspects of their work, because there is no comprehensive, interactive AI assistant.
    • AI co-mathematician is an interactive workbench that uses a hierarchy of AI agents built on the Gemini language model to manage and execute mathematical research tasks.
    • The system uses a project coordinator agent to refine user intent and delegates tasks to a parallel-workstream coordinator agent that uses specialized subagents for literature review, coding, proof, and computational exploration.
    • The system focuses on producing 'living working papers' with internal links, margin notes for citation, and iterative AI-led review loops, while supporting asynchronous interaction and flexible user steering.
    AbstractPDF
  11. 184Reasoning / Test-Time ScalingarXiv:2605.08083

    LLMs Improving LLMs: Agentic Discovery for Test-Time Scaling

    • Test-time scaling strategies for large language models are usually developed through manual design and heuristic tuning.
    • This reliance on human intuition limits the search over complex computation-allocation policies and makes them vulnerable to human cognitive bias.
    • Manual methods often produce strategies that are specific to a task or model, which leads to suboptimal accuracy-cost trade-offs across broader settings.
    • AutoTTS formulates test-time scaling as a controller synthesis problem, where a searcher LLM repeatedly proposes and refines policies defined in code.
    • The method uses an offline replay environment to collect reasoning trajectories in advance, which allows candidate controllers to be evaluated cheaply and deterministically without live LLM calls.
    • The framework introduces a beta parameterization to simplify the hyperparameter search space and provides fine-grained execution traces as feedback for robust discovery.
    AbstractPDF
  12. 183Agents / Multi-Agent / SurveyarXiv:2605.14892

    Beyond Individual Intelligence: Surveying Collaboration, Failure Attribution, and Self-Evolution in LLM-based Multi-Agent Systems

    • Individual LLM agents run into limits on sustained coordination, adaptation, and multi-step tasks across roles and environments.
    • Existing research on LLM-based agents is fragmented, with individual capability, multi-agent collaboration, and self-evolution treated as separate topics, which blocks a holistic understanding of their interdependence.
    • In tightly coupled multi-agent systems, error propagation and cascading failures are hard to diagnose automatically, and current systems lack mechanisms that turn diagnostic insight into structured self-improvement.
    • The paper presents the LIFE progression framework, which structures the operational lifecycle into four causally linked stages: Lay for capability-based build-up, Integrate for agent integration through collaboration, Find for defect discovery through cause attribution, and Evolve for autonomous self-improvement.
    • It systematically reviews and formalizes each stage, including taxonomies of individual agent components, multi-agent collaboration mechanisms, failure attribution methods, and self-evolution mechanisms.
    • It proposes and analyzes a closed-loop self-improvement framework in which failure diagnosis feeds directly into structural adaptation, such as collaboration reconfiguration or agent behavior improvement.
    AbstractPDF
  13. 182LLMs / Memory / ArchitecturearXiv:2605.12357

    $δ$-mem: Efficient Online Memory for Large Language Models

    • Large language models, or LLMs, struggle to use long interaction histories efficiently because of the quadratic compute cost of expanded context windows and context degradation.
    • Current memory mechanisms, including text-based, external-channel, and parametric approaches, suffer from information loss, retrieval noise, integration overhead, or the inability to adapt dynamically.
    • There is a need for a way to provide LLMs with continuous and adaptable memory without full model fine-tuning or large architectural changes.
    • delta-mem compresses continuous past information into a fixed-size associative memory online state, or OSAM, which enables efficient and dynamic storage.
    • The method operates through a sequential read-adjust-write cycle, where signals read from OSAM generate low-rank corrections to the frozen backbone's attention mechanism and a gated delta rule updates OSAM.
    • The system provides multiple write units, namely Token-State, Sequence-State, and Multi-State Write, so that memory updates can be adapted to different contexts and backbone capacities.
    AbstractPDF
  14. 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
  15. 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
  16. 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
  17. 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
  18. 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
  19. 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
  20. 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
  21. 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
  22. 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
  23. 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
  24. 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
  25. 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
  26. 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
  27. 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
  28. 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
  29. 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
  30. 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
  31. 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
  32. 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
  33. 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
  34. 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
  35. 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
  36. 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
  37. 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
  38. 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
  39. 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
  40. 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
  41. 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
  42. 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
  43. 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
  44. 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
  45. 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
  46. 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
  47. 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
  48. 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
  49. 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
  50. 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