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. 131Agents / BenchmarksarXiv:2603.28052

    Meta-Harness: End-to-End Optimization of Model Harnesses

    • The core idea is to treat the harness as executable stateful code rather than a prompt template, and to search the end-to-end logic of retrieval, memory, prompt assembly, and environment handling.
    • In the optimization loop, a coding-agent proposer explores an uncompressed filesystem of prior code, scores, prompts, model outputs, tool calls, and traces, then submits a new harness candidate for evaluation.
    • In the empirical results, online classification accuracy was 48.6 percent versus 40.9 percent for ACE while using four times fewer context tokens, average accuracy improved by 4.7 points on 200 IMO-level math problems across five held-out models, and TerminalBench-2 results reached 37.6 percent for Claude Haiku 4.5 and 76.4 percent for Claude Opus 4.6 in the alphaXiv report.
    • The significance is that raw traces let the proposer debug long-horizon credit-assignment failures, such as when an early memory miss causes a later answer failure that a score-only or summary-only optimizer would miss.
    AbstractPDF
  2. 130Code AgentsarXiv:2603.21489

    Effective Strategies for Asynchronous Software Engineering Agents

    • The core method is this: a manager builds a task dependency graph, delegates only qualified nodes, and updates the state when engineer agents complete sub-tasks.
    • The execution model is this: engineers edit in isolated git worktrees, run local tests before committing, and return changes through a structured branch-and-merge pipeline.
    • Empirically, CAID improves PaperBench by 26.7 percentage points and Commit0-Lite by 14.3 percentage points over the single-agent baseline, suggesting gains in both accuracy and long-horizon coordination.
    • A key takeaway is that parallelism has an optimum. Two to four engineers help, but with eight engineers results can worsen as merge conflicts, dependency waits, and verification overhead outweigh the added headcount.
    AbstractPDF
  3. 129Agents / MetacognitionarXiv:2603.19461

    Hyperagents

    • Existing self-improving AI systems rely on fixed, hand-crafted meta-level mechanisms, which limits their ability to improve continuously and leads to an infinite regress problem.
    • Existing self-improving frameworks often lack generalizability because their effectiveness is tied to domain-specific alignment between task-solving and self-modification skills.
    • The challenge is to achieve truly open-ended, self-accelerating progress in which not only task-solving ability but also the improvement mechanism itself can be strengthened.
    • It introduces Hyperagents, a self-referential agent that integrates a task-solving agent and a modifier-generating meta-agent into a single editable program.
    • It extends the Darwin Gödel Machine, or DGM, framework into DGM-Hyperagents, or DGM-H, enabling metacognitive self-modification by allowing the meta-agent component inside the hyperagent to modify both the task agent and itself.
    • It uses an open-ended population-based search process that stores improved hyperagents as stepping stones for future iterative refinement, across domains such as coding, paper review, and robotics.
    AbstractPDF
  4. 128Multimodal / ReasoningarXiv:2603.03975

    Phi-4-reasoning-vision-15B Technical Report

    • The dominant trend in vision-language models (VLMs) is to keep increasing model size, which brings huge training and inference costs and hinders broad deployment.
    • Many existing multimodal models struggle with tasks that require fine-grained visual detail, such as understanding user interfaces for computer-use agents, because their perceptual ability is limited.
    • There is a need for practical insights and open-weight models that can achieve efficient and capable multimodal reasoning without demanding enormous resources.
    • We developed Phi-4-reasoning-vision-15B, a 15-billion-parameter open-weight multimodal model with an intermediate-fusion architecture that uses the SigLIP-2 vision encoder and the Phi-4-Reasoning LLM backbone.
    • We implemented a three-stage training recipe consisting of MLP pretraining, extensive instruction tuning on diverse and carefully curated datasets, and a final stage for long context, multiple images, and responsible AI (RAI) data.
    • We emphasized data quality through systematic filtering, AI-assisted error correction, and synthetic augmentation, and integrated a dynamic-resolution vision encoder to optimize high-resolution visual perception.
    AbstractPDF
  5. 127Agents / ArchitecturearXiv:2602.23720

    The Auton Agentic AI Framework

    • There is a fundamental mismatch between the probabilistic outputs of large language models, or LLMs, and the deterministic, schema-compliant input requirements of backend infrastructure, a problem the paper calls the integration paradox.
    • The widespread fragmentation of the agent development ecosystem is characterized by the absence of unified standards, which leads to vendor lock-in, poor auditability, and limited portability across languages.
    • Current LLM-based agents are often stateless, lack persistent memory, and provide limited safety guarantees, which makes them difficult to deploy in real mission-critical environments.
    • It strictly separates an agent specification layer, a declarative, language-agnostic cognitive blueprint called AgenticFormat Standard, from an execution layer, a platform-specific runtime engine.
    • To ensure deliberate behavior, it presents a formal agent execution model based on an extended partially observable Markov decision process, or POMDP, with a latent reasoning space and factored policy structure.
    • It presents a hierarchical memory structure for cognitive persistence and a constraint-manifold formalism that enforces safety by design through policy projection during action generation.
    AbstractPDF
  6. 126Memory / AgentsarXiv:2602.23320

    ParamMem: Augmenting Language Agents with Parametric Reflective Memory

    • Existing self-reflection mechanisms in language agents often generate repetitive, inaccurate, or unhelpful outputs, undermining their ability to explore diverse solutions and diagnose errors.
    • Existing retrieval-based approaches for improving reflective diversity, such as DoT-bank, are limited in their ability to capture compositional patterns and are vulnerable to embedding collapse, which reduces retrieval effectiveness.
    • Empirical evidence shows a strong positive correlation between reflective diversity and task success in language agents, with a mean Pearson coefficient of 0.76.
    • ParamMem builds a parametric memory module by fine-tuning a lightweight LLM, such as LLaMA-3.1-8B with LoRA, on an auxiliary dataset of input samples paired with expert-generated global reflections.
    • The fine-tuned ParamMem module generates diverse reflections through temperature-controlled sampling and directly encodes cross-sample patterns into its parameters.
    • ParamMem is integrated into agent frameworks, including ParamAgent and ParamAgent-plus, to combine this parametric memory with existing episodic memory and, in the case of ParamAgent-plus, with cross-sample memory such as DoT-bank to condition the actor LLM.
    AbstractPDF
  7. 125Math Reasoning / Formal ProofsarXiv:2601.14027

    Numina-Lean-Agent: An Open and General Agentic Reasoning System for Formal Mathematics

    • Existing agentic theorem-proving systems often rely on task-specific reasoning pipelines tightly coupled to heavily trained formal provers.
    • Many high-performance automatic theorem provers are closed source, which limits transparency, reproducibility, and broader community progress.
    • Existing single-model approaches have struggled with the long-horizon structural reasoning inherent in complex formal systems such as Lean.
    • The paper proposes a paradigm in which a general-purpose coding agent, specifically Claude Code, serves as the central orchestrator for formal mathematical reasoning.
    • It develops Numina-Lean-Agent, an open and modular system that integrates Claude Code with a comprehensive model context protocol called Numina-Lean-MCP.
    • Numina-Lean-MCP includes specialized tools for deep interaction with Lean via Lean-LSP-MCP, semantic theorem retrieval via LeanDex, iterative informal proving via Gemini Generator and Verifier, and multi-model collaboration via Discussion Partner.
    AbstractPDF
  8. 124Multi-AgentarXiv:2603.00142

    Evaluating Theory of Mind and Internal Beliefs in LLM-Based Multi-Agent Systems

    • LLM agents often show inconsistent and variable performance in complex multi-agent systems, especially when dealing with partial or conflicting information.
    • Existing multi-agent systems often rely on rigid rules, which limits their adaptability and scalability in dynamic real-world environments.
    • A comprehensive, synergistically integrated structure that combines theory of mind (ToM), internal belief systems, and logical verification is still missing from LLM-based multi-agent systems.
    • We propose a new agent architecture that integrates theory of mind (ToM) capability, internal belief states (IB), and logical verification using an answer set programming (ASP) solver.
    • We deployed these agents in an interactive city resource allocation simulation designed to require effective coordination under dynamic, resource-consuming scenarios.
    • The modular agent design enabled systematic evaluation of four configurations, baseline, ToM only, IB only, and ToM plus IB, across different LLMs, with iterative logical consistency checks on internal beliefs.
    AbstractPDF
  9. 123InterpretabilityarXiv:2602.15029

    Symmetry in language statistics shapes the geometry of model representations

    • There has long been no clear and unified theoretical explanation for the geometric patterns, such as circles and one-dimensional manifolds, that are widely observed in language model representations.
    • There is no comprehensive organizing principle that explains the apparent universality of these geometric structures across different LLM architectures and tasks.
    • Existing theoretical work has not sufficiently explained how data distributions and unsupervised learning settings induce these specific representation geometries.
    • The paper proposes that translational symmetry in pairwise word co-occurrence statistics acts as a universal organizing principle for representation geometry.
    • From this symmetry, it develops a mathematical theory that analytically derives specific manifold geometries, such as circles and wavy one-dimensional manifolds.
    • It empirically validates these theoretical predictions using both simple word embedding models and complex Transformer-based large language models.
    AbstractPDF
  10. 122Reasoning / ProbabilisticarXiv:2503.17523

    Bayesian Teaching Enables Probabilistic Reasoning in Large Language Models

    • Off-the-shelf large language models, or LLMs, lack the ability to form and update probabilistic beliefs effectively in uncertain, interactive environments.
    • Current LLMs perform poorly at implicitly inferring latent states, such as user preferences, from observed behavior across multiple interactions.
    • Their recommendation accuracy often plateaus early, which suggests a fundamental limitation in dynamically updating beliefs from new information.
    • The authors developed Bayesian teaching, a supervised fine-tuning strategy that trains LLMs on data generated by a normative Bayesian assistant.
    • The Bayesian assistant maintains and updates a probability distribution over user preferences with Bayes' rule and produces probabilistically optimal recommendations.
    • This approach was compared with oracle teaching, which fine-tunes the LLM on consistently correct answers from an assistant with full knowledge.
    AbstractPDF
  11. 121Brain-Computer Interface / AgentsarXiv:2603.03212

    NeuroSkill(tm): Proactive Real-Time Agentic System Capable of Modeling Human State of Mind

    • Existing generative AI agents lack a fine-grained understanding of human cognitive and emotional states, which leads to generic and often inappropriate interactions.
    • Although the amount of personal biosignal data from BCI devices is increasing, it is often controlled by large companies, which limits personal utility and data ownership.
    • Current AI agents are mainly reactive and do not actively adapt in real time to changing human emotional and cognitive states.
    • NeuroSkill combines BCI data collection, a local EXG foundation model for neural embeddings, and multimodal alignment with text context to build a continuously updated representation of the dynamic human state of mind.
    • NeuroLoop, an LLM harness running on edge devices, uses the modeled state of mind to enable proactive, personalized agentic interaction, tool use, and protocol execution.
    • A simple Markdown-based skill layer lets non-developers easily extend and modify agent behavior, which improves accessibility and broad personalization.
    AbstractPDF
  12. 120Scientific AIarXiv:2602.03837

    Accelerating Scientific Research with Gemini: Case Studies and Common Techniques

    • Integrating AI into scientific research has traditionally focused on automation and data analysis rather than deeper intellectual tasks such as hypothesis generation or algorithm design.
    • Scientists have struggled to efficiently solve open conjectures, identify subtle interdisciplinary connections, and rigorously verify complex proofs.
    • Existing scientific workflows would benefit from tools that go beyond routine tasks and can engage in creative problem solving and rigorous technical review.
    • The core methodology involved human researchers collaborating with Google Gemini Deep Think and its variants, which were strengthened for complex problem solving through parallel thinking and multi-step reasoning training.
    • Common collaboration techniques included iterative prompting, decomposing problems into subtasks, providing high-level proof scaffolding, and using adversarial self-correction for rigorous review.
    • For problems requiring numerical grounding, a neuro-symbolic pipeline was used in which AI proposed a solution, wrote and ran verification code, and then self-corrected based on execution errors.
    AbstractPDF
  13. 119Agents / ArchitecturearXiv:2602.03695

    Agent Primitives: Reusable Latent Building Blocks for Multi-Agent Systems

    • Existing multi-agent systems, or MAS, suffer from task specificity, high design overhead, and low reuse across different problem settings.
    • Communication between agents, usually through natural language, can become unstable, accumulate errors, and lose information during long, multi-step interactions.
    • Current MAS designs often lack truly reusable, task-agnostic internal abstractions for organizing multi-agent operations.
    • The paper introduces Agent Primitives, three reusable latent building blocks, namely Review, Voting & Selection, and Planning & Execution, that encapsulate common multi-agent operation patterns.
    • It implements inter-agent communication using only Key-Value, or KV, cache transfer, which shares internal model representations directly without relying on explicit natural language.
    • It also develops an LLM-based Organizer guided by a Knowledge Pool to automatically select and compose primitives for a given query, which simplifies MAS construction.
    AbstractPDF
  14. 118RAG / AgentsarXiv:2602.03442

    A-RAG: Scaling Agentic Retrieval-Augmented Generation via Hierarchical Retrieval Interfaces

    • Existing RAG paradigms that rely on a single retrieval step or a predefined workflow do not fully exploit the advanced reasoning and multi-step tool-use abilities of modern agentic LLMs.
    • Current RAG systems are static and rigid, which prevents the LLM from dynamically adjusting its retrieval strategy according to query nuance or the current state of information gathering.
    • The lack of agentic autonomy in traditional RAG limits scaling with LLM capability, because the model is not allowed to make intelligent retrieval decisions.
    • A-RAG builds a lightweight two-stage hierarchical index without large offline graph construction by splitting the corpus into semantically coherent chunks and embedding individual sentences for fine-grained matching.
    • The framework gives LLM agents three hierarchical retrieval interfaces: keyword search for exact lexical matching, semantic search for dense semantic similarity, and chunk reading for access to whole chunk content and nearby context.
    • Through a simple ReAct-like agent loop, the LLM repeatedly reasons and calls retrieval tools to decide what to retrieve, how to retrieve it, and when to stop, and a context tracker helps avoid redundant reading.
    AbstractPDF
  15. 117Memory / Long ContextarXiv:2602.02704

    InfMem: Learning System-2 Memory Control for Long-Context Agent

    • Large language models struggle with effective multi-hop reasoning over ultra-long documents because of the middle loss phenomenon and the fidelity dilemma of compression.
    • Existing memory-augmented agents often rely on passive and reactive memory update strategies, which risks losing decisive but low-salience evidence needed for complex reasoning.
    • Ultra-long document processing introduces high compute costs and memory overhead, making current solutions inefficient for practical deployment.
    • InfMem implements a control protocol of pre-think, retrieve, and record, allowing the agent to actively monitor evidence sufficiency, synthesize retrieval queries, and perform evidence-aware coupled compression.
    • It enables non-monotonic access to any part of the document so that it can fetch missing evidence for the current query, including targeted retrieval inside the document.
    • The framework uses an adaptive early-stopping mechanism that ends the memory update loop once sufficient evidence has accumulated, optimizing compute efficiency.
    AbstractPDF
  16. 116Multi-Agent / RoutingarXiv:2602.02751

    Scaling Small Agents Through Strategy Auctions

    • The performance of smaller AI agents relative to larger models on complex long-horizon tasks has not been well understood.
    • Effectively routing tasks to the best AI agent from a heterogeneous pool of models with different sizes, costs, and capabilities was a challenge for optimizing both accuracy and cost.
    • Current routing methods for multi-model orchestration are often too expensive for agentic workflows, or they generalize poorly and degrade as task difficulty increases.
    • Strategy Auctions for Workload Efficiency (sale) is introduced as a market-inspired framework for dynamic task allocation across heterogeneous AI agents.
    • Agents generate short strategic solution plans for each task as bids, which are evaluated by a learned cost-value mechanism that accounts for model price and plan quality.
    • The framework includes a memory-based self-improvement loop in which cheaper agents selectively improve their strategies using past auction outcomes, raising performance over time.
    AbstractPDF
  17. 115Memory / AgentsarXiv:2602.02007

    Beyond RAG for Agent Memory: Retrieval by Decoupling and Aggregation

    • Standard retrieval-augmented generation does not fit agent memory well.
    • Unlike large heterogeneous corpora, agent memory forms a bounded and coherent interaction stream in which many spans are strongly correlated or nearly redundant.
    • As a result, flat top-k similarity search often returns redundant context, while summary-centric hierarchies blur the subtle details that distinguish one candidate from another.
    • The paper argues that agent memory should follow the principle of separation before aggregation, meaning the system should first separate reusable facts, updates, and distinguishing details from similar histories before organizing them for efficient retrieval.
    • Based on this principle, the authors propose xMemory, which builds a mutable hierarchical memory structure from original messages to segments, memory components, and groups.
    • xMemory splits interaction history into local events, separates each segment into memory components, aggregates relevant components into higher-level groups using sparsity and semantic fidelity objectives, and preserves this structure incrementally as memory evolves.
    AbstractPDF
  18. 114Fine-tuning / EfficiencyarXiv:2602.04118

    Learning to Reason in 13 Parameters

    • Fine-tuning large language models traditionally requires updating billions of parameters, which leads to high compute and memory costs.
    • Existing parameter-efficient fine-tuning (PEFT) methods reduce parameter count but still operate at the scale of millions or tens of thousands, limiting their use in constrained environments.
    • It is especially important to understand the fundamental minimum number of parameters needed for effective adaptation on complex reasoning tasks.
    • The paper introduces TinyLoRA, a new PEFT method that extends LoRA-XS by replacing trainable r×r matrices with low-dimensional trainable vectors projected through fixed random tensors, greatly reducing per-module parameters.
    • It implements an aggressive weight-sharing strategy so that trainable vectors are shared across many or all layers of the model, reducing the total number of trainable parameters to single digits.
    • It uses reinforcement learning, especially GRPO, as the core training algorithm to show that sparse reward-based signals can be exploited with highly constrained parameter updates.
    AbstractPDF
  19. 113Math / Scientific AIarXiv:2601.22401

    Semi-Autonomous Mathematics Discovery with Gemini: A Case Study on the Erdős Problems

    • Many problems in the Erdős Problems database are labeled as Open, but some may already have existing solutions that are simply not well known.
    • Human mathematicians face an attention bottleneck when they try to systematically evaluate a large number of unproven conjectures and conduct broad literature searches.
    • Rigorous benchmarking of advanced large language models on complex mathematical problem solving requires suitable and diverse datasets.
    • A specialized Gemini-based AI agent called Aletheia was tasked with generating candidate solutions for 700 Open Erdős problems and performing an initial natural-language verification.
    • A strict multi-stage human evaluation framework, including expert filtering, detailed review, and external consultation, was used to judge the correctness and novelty of the AI outputs.
    • Extensive literature searches and analysis of AI reasoning logs were conducted to distinguish genuinely new results from independent rediscovery or confirmed existing solutions.
    AbstractPDF
  20. 112Memory / RL / AgentsarXiv:2601.03192

    MemRL: Self-Evolving Agents via Runtime Reinforcement Learning on Episodic Memory

    • AI agents struggle to continue acquiring skills after deployment without catastrophically forgetting previously learned knowledge.
    • Fine-tuning large language models for continual adaptation is computationally expensive and highly prone to catastrophic forgetting.
    • Existing retrieval-augmented generation systems are passive and often retrieve semantically relevant but low-utility noise from memory, which hinders learning from environmental feedback.
    • MemRL separates a stable, frozen LLM backbone from a dynamic, plastic external episodic memory, enabling continual learning without weight updates or catastrophic forgetting.
    • The system formulates memory retrieval as a memory-based Markov decision process, in which the retrieval policy, not the LLM parameters, is optimized by reinforcement learning.
    • It uses an intent-experience-utility triple-memory structure and a two-stage retrieval mechanism that combines semantic recall with value-aware selection to actively filter and exploit high-utility experiences.
    AbstractPDF
  21. 111Memory / AgentsarXiv:2601.02553

    SimpleMem: Efficient Lifelong Memory for LLM Agents

    • Large language models (LLMs) struggle with fixed context windows, which limits their ability to retain information across long-term memory and extended interactions.
    • Memory systems for LLM agents suffer from context bloat caused by redundant and low-entropy conversations, which reduces effective information density and model performance.
    • Current approaches to augmenting LLM memory incur substantial computational overhead, including high token costs and increased latency, which hinders practical deployment.
    • The framework features a three-stage memory pipeline that includes semantic structured compression, multidimensional structured indexing with recursive consolidation, and adaptive query-aware retrieval.
    • It implements entropy-aware filtering to remove redundant conversations and normalize informative content into self-contained, context-independent memory units.
    • It uses multilayer indexing, semantic, lexical, and symbolic, along with an asynchronous background process for recursive consolidation, to produce higher-level abstract memory representations.
    AbstractPDF
  22. 110Evaluation / AgentsarXiv:2601.05111

    Agent-as-a-Judge

    • Traditional AI evaluation methods, including predefined metrics and human judgment, have been insufficient to capture semantic nuance, or they have been hard to scale and expensive.
    • Early LLM-as-a-Judge paradigms face limitations such as intrinsic parameter bias, shallow single-pass reasoning, lack of real-world verification, and cognitive overload on complex, multi-dimensional tasks.
    • The rapidly growing field of Agent-as-a-Judge lacked a unified framework, comprehensive taxonomy, and clear roadmap for organizing its diverse methods and applications.
    • This paper introduces a new three-stage maturity taxonomy for agentic evaluation systems based on autonomy and adaptability: Procedural, Reactive, and Self-Evolving Agent-as-a-Judge.
    • It systematically classifies core agentic methodologies, including multi-agent collaboration, planning, tool integration, memory and personalization, and optimization paradigms.
    • The survey comprehensively reviews Agent-as-a-Judge applications across broad general domains, such as mathematics, code, and fact checking, as well as specialized domains, such as medicine, law, finance, and education.
    AbstractPDF
  23. 109Memory / EfficiencyarXiv:2601.07190

    Active Context Compression: Autonomous Memory Management in LLM Agents

    • LLM agents suffer from context bloat on long tasks because their conversation history keeps growing, which raises compute cost and latency.
    • An expanded context window can reduce reasoning quality through context poisoning, where irrelevant information overwhelms the useful content, and through the lost-in-the-middle effect.
    • Existing solutions such as external memory systems and reflection mechanisms often fail to provide active in-trajectory context management during sustained task execution.
    • The Focus architecture extends the ReAct agent loop with two primitives, Focus Begin and Focus Complete, so that the agent can autonomously start and end compression phases.
    • At Focus Complete, the agent generates a high-level summary of its activity and learning, appends it to a persistent Knowledge block, and deletes the raw interaction history to create a dynamic sawtooth context pattern.
    • This approach is inspired by biological exploration strategies such as slime mold behavior and emphasizes synthesis of abstract learning over preservation of the full raw record.
    AbstractPDF
  24. 108Memory / AgentsarXiv:2601.01885

    Agentic Memory: Learning Unified Long-Term and Short-Term Memory Management for Large Language Model Agents

    • LLM agents struggle with long-horizon reasoning because of their finite context window, which makes effective memory management necessary.
    • Traditional memory systems treat long-term and short-term memory as independent components, which leads to fragmented and heuristic-based solutions with suboptimal coordination.
    • Optimizing memory operations with standard reinforcement learning is difficult because reward signals are sparse and discontinuous over long trajectories.
    • AgeMem formalizes LTM operations, namely ADD, UPDATE, and DELETE, and STM operations, namely RETRIEVE, SUMMARY, and FILTER, as explicit tool-based actions within the agent policy, enabling autonomous and learnable memory control.
    • To learn comprehensive memory capability, it uses a three-stage progressive reinforcement learning strategy covering LTM construction, STM control with distractors, and integrated reasoning.
    • Stage-wise Group Relative Policy Optimization, or GRPO, ensures a consistent learning signal for memory decisions by propagating the terminal reward uniformly across trajectory steps, which addresses the sparse-reward problem.
    AbstractPDF
  25. 107Agents / SearcharXiv:2601.07055

    Dr. Zero: Self-Evolving Search Agents without Training Data

    • A major problem is the need to rely on expensive human-curated training data to develop advanced search and reasoning LLMs.
    • Existing data-free self-evolution frameworks have limitations in generating diverse and challenging open-domain questions for multi-hop reasoning.
    • Existing reinforcement learning methods for optimizing multi-turn search agents that interact with external tools are computationally inefficient.
    • It is a self-evolving proposer-solver framework in which both agents are trained without human data and rely only on external search engines for fact checking.
    • Hop-Grouped Relative Policy Optimization (HRPO) is introduced for efficient proposer training, grouping questions by hop complexity and using group-level baselines to reduce compute overhead.
    • Difficulty-based rewards are used so the proposer generates diverse, challenging, yet verifiable multi-hop questions, creating a dynamic curriculum.
    AbstractPDF
  26. 106World ModelsarXiv:2601.05230

    Learning Latent Action World Models In The Wild

    • Most successful world models rely on explicit action labels, which limits scalability and generality when they are applied to massive amounts of unlabeled real-world video data.
    • Existing latent action models (LAMs) have been confined to limited environments, which has produced action spaces with weak transferability and poor generalization to diverse real-world scenarios.
    • Wild videos introduce problems such as poorly defined actions, environmental noise, and the lack of a shared embodiment, which makes it difficult to extract meaningful action representations.
    • Using the frozen V-JEPA 2-L visual encoder, the framework jointly learns a world model and inverse dynamics models from large-scale unlabeled in-the-wild video datasets.
    • It investigates information regularization methods, including sparsity, noise injection in a VAE-like form, and discretization, to control the content of continuous latent actions and prevent irrelevant information from being encoded.
    • It evaluates the learned latent action space using intrinsic metrics such as future leakage and action transferability, as well as practical utility on downstream planning tasks through a lightweight controller and the Cross-Entropy Method.
    AbstractPDF
  27. 105Architecture / LearningarXiv:2601.00417

    Deep Delta Learning

    • Deep residual networks, or ResNets, impose a strictly additive inductive bias through identity shortcut connections, which limits the complexity of learnable feature transformations.
    • The fixed identity Jacobian of ResNet shortcut connections constrains the network's ability to model complex, non-monotonic state transitions that require dynamics often characterized by negative eigenvalues, such as oscillation or adversarial behavior.
    • Standard residual updates, which can be viewed as forward Euler steps, exhibit a strong translational bias and lack an explicit mechanism for feature forgetting or reorientation.
    • The paper introduces the Delta Residual Block, which extends the usual additive residual update, where the next layer equals the current layer plus a transformed term, into a multiplicative form that multiplies the shortcut connection by a data-dependent geometric transform matrix and a key-value correction term.
    • The key is the Delta Operator, in which A(X) = I − β(X) times the outer product of k(X) with itself. This rank-1 perturbation of the identity matrix applies a spatial geometric transformation.
    • The operator is parameterized by a learnable, data-dependent reflection direction k(X) and a gating scalar beta(X) that is dynamically controlled in the range from 0 to 2.
    AbstractPDF
  28. 104Benchmarks / CodearXiv:2512.18470

    SWE-EVO: Benchmarking Coding Agents in Long-Horizon Software Evolution Scenarios

    • Existing AI coding-agent benchmarks mostly focus on isolated bug fixes or single-issue feature implementations, as seen in SWE-Bench.
    • These benchmarks do not adequately capture the long-horizon nature of real software engineering, which involves continuous evolution, multi-file coordination, and iterative updates to existing codebases.
    • A large share of software development is spent maintaining and evolving legacy code, which requires persistent understanding, adaptive planning, and holistic system changes that current methods do not evaluate.
    • SWE-EVO presents a benchmark of 48 high-quality software evolution tasks derived from real release notes, requiring the agent to switch between two distinct versions of a codebase.
    • The agent must interpret a high-level software requirements specification, or SRS, and implement multi-step, multi-file changes across the entire codebase while preserving functionality and ensuring that new tests pass.
    • Performance is evaluated with solve rate under strict pass or fail rules, patch apply rate, and edit rate as a finer-grained measure of progress, and it is supplemented with LLM-as-a-judge analysis to classify failure modes.
    AbstractPDF
  29. 103Scientific AI / RLarXiv:2512.23707

    Training AI Co-Scientists Using Rubric Rewards

    • Existing AI applications for science are usually limited to well-defined and executable environments, which reduces their usefulness for abstract and open-ended scientific inquiry.
    • Large language models struggle to generate high-quality long-form research plans because obtaining human feedback in scientific contexts is slow, expensive, and often ambiguous.
    • The main bottleneck is scaling the collection of highly specialized learning data and feedback for open-ended scientific tasks, since manual annotation by human experts is costly and time-consuming.
    • The paper builds an automated pipeline called ResearchPlanGen that extracts research goals, goal-specific grading rubrics, and reference solutions directly from scientific papers to create large and diverse training datasets.
    • It implements a self-graded reinforcement learning framework in which a frozen copy of the initial language model acts as an auto-grader that scores generated plans using privileged goal-specific rubrics and general guidelines.
    • The plan generator is optimized with Group Relative Policy Optimization (GRPO) using the rubric satisfaction score as a direct reward signal, along with a length-control strategy to enforce conciseness.
    AbstractPDF
  30. 102RL / TrainingarXiv:2601.05242

    GDPO: Group reward-Decoupled Normalization Policy Optimization for Multi-reward RL Optimization

    • Aligning large language models with diverse human preferences, such as safety, consistency, and efficiency, requires multi-reward reinforcement learning.
    • The commonly used Group Relative Policy Optimization, or GRPO, algorithm suffers from reward-signal collapse when applied to the sum of multiple rewards, meaning that different reward combinations can produce the same advantage value.
    • This collapse reduces the resolution of the learning signal, leading to suboptimal convergence, poorer training stability, and potential early training failure.
    • GDPO preserves fine-grained distinctions by decoupling normalization of individual reward components and performing group-wise normalization separately for each reward.
    • The individually normalized advantages are then summed and passed through an additional batch-level normalization step to ensure numerical stability during policy updates.
    • To manage priority across rewards, GDPO explores reward weighting and proposes reward-function conditioning, which gives easier rewards only when harder goals have been achieved.
    AbstractPDF
  31. 101Security / CodearXiv:2601.03335

    Digital Red Queen: Adversarial Program Evolution in Core War with LLMs

    • Understanding open-ended adversarial evolution, known as Red Queen dynamics, in controlled artificial systems is a difficult problem.
    • Efficiently navigating an extremely sparse search space for programs that operate in complex adversarial environments is a difficult problem.
    • The challenge is to develop a simple yet effective self-play mechanism that induces continuous adaptation and counter-adaptation in digital ecosystems.
    • Digital Red Queen (DRQ) is a minimal self-play mechanism in which each round evolves a new program to optimize against all previously generated adversaries.
    • It uses Core War as a sandboxed Turing-complete environment for evolving self-modifying Redcode programs, providing a safe testbed for complex adversarial dynamics.
    • It integrates a large language model such as GPT-4.1 mini as an intelligent mutation and generation operator inside the MAP-Elites quality-diversity algorithm to guide program synthesis and preserve diversity.
    AbstractPDF
  32. 100ArchitecturearXiv:2512.24601

    Recursive Language Models

    • Large language models (LLMs) are constrained by finite context windows, which makes them difficult to apply to many real long-horizon tasks that can involve millions of tokens.
    • LLMs exhibit context rot, meaning performance degrades as input length grows even within a fixed context window, especially on tasks that require dense information access.
    • Existing approaches to long-context management, such as compression, summarization, or task-specific agent systems, are often inadequate because they lose information, generalize poorly, or still run into the core context-window limit of LLMs.
    • Instead of feeding an arbitrarily long user prompt directly into the LLM context window, the method treats it as an external object inside a persistent REPL (Read-Eval-Print Loop) programming environment.
    • It lets the LLM generate code inside the REPL to inspect, transform, decompose, and build intermediate values from the external prompt programmatically.
    • By enabling symbolic recursion in code, the method can call sub-RLMs on programmatically constructed prompt transformations, bypassing output-length limits and enabling complex iterative processing.
    AbstractPDF
  33. 099ArchitecturearXiv:2512.10938

    Stronger Normalization-Free Transformers

    • Traditional normalization layers such as Batch Norm and Layer Norm stabilize deep neural network training but incur overhead from memory access and synchronization and remain sensitive to batch size.
    • Existing normalization-free methods like Dynamic Tanh (DyT) achieve performance comparable to normalization, but they do not systematically surpass it, leaving room for further improvement.
    • There has been a lack of systematic understanding of how the intrinsic properties of pointwise functions affect training dynamics and model performance in normalization-free Transformers.
    • The paper systematically analyzes four intrinsic properties of pointwise functions, zero-centeredness, boundedness, central sensitivity, and monotonicity, to derive design principles for effective normalization-free Transformer components.
    • Based on these principles, the authors extensively explore pointwise functions empirically and identify the error function (erf) as the best-performing design.
    • They develop Dynamic erf (Derf), a pointwise function parameterized as "γ × erf(αx+s)+β" by applying scale, shift, and bias parameters to the error function, which serves as a statistically independent alternative that directly replaces all normalization layers in Transformer architectures.
    AbstractPDF
  34. 098Cybersecurity / AgentsarXiv:2512.09882

    Comparing AI Agents to Cybersecurity Professionals in Real-World Penetration Testing

    • Existing AI cybersecurity benchmarks are often run in abstract environments, so they lack the operational realism and complexity of live production systems.
    • There has been a substantial gap in empirically comparing AI agents with human cybersecurity experts on penetration testing against real operational systems.
    • Current AI agent architectures for offensive security often struggle with context management and long-horizon tasks in dynamic operational environments.
    • We compared human cybersecurity experts with diverse AI agents on a large, heterogeneous real-world university enterprise network with 8,000 hosts and 12 subnets.
    • We introduced ARTEMIS, a new multi-agent AI scaffold designed for complex cybersecurity tasks, featuring a supervisor agent, subagents, dynamic prompt generation, and a triage module.
    • We developed a unified scoring system that quantifies vulnerability discovery based on business impact, reflecting technical complexity and weighting, enabling direct comparison across participants.
    AbstractPDF
  35. 097Benchmarks / FactualityarXiv:2512.10791

    The FACTS Leaderboard: A Comprehensive Benchmark for Large Language Model Factuality

    • Large language models frequently generate factually incorrect information, which undermines reliable deployment in real-world applications.
    • Existing benchmarks for LLM factuality often focus on narrow abilities, such as context-grounded or general knowledge recall, and therefore fail to provide a holistic evaluation.
    • Real LLM applications require combinations of factual capabilities across different modalities and knowledge sources, which current evaluation frameworks do not adequately cover.
    • The FACTS Leaderboard consists of four separate sub-leaderboards, FACTS Multimodal, FACTS Parametric, FACTS Search, and FACTS Grounding v2, each of which evaluates a specific dimension of LLM factuality.
    • The benchmark evaluates model responses across thousands of diverse questions using sophisticated automatic judges that have been rigorously validated against human annotations.
    • Kaggle conducts all evaluations fairly, with public and private data splits that preserve benchmark integrity and reduce overfitting.
    AbstractPDF
  36. 096RAGarXiv:2511.18659

    CLaRa: Bridging Retrieval and Generation with Continuous Latent Reasoning

    • Traditional retrieval-augmented generation systems suffer from separate optimization, where the retriever and generator are optimized independently, which creates a mismatch between retrieved information and the generator's actual needs.
    • RAG systems often process long, uncompressed text contexts, which leads to high inference cost, redundant text handling, context overflow in LLMs, and a structural mismatch between embedding-based retrieval and raw-text-based generation.
    • The discrete nature of document selection in retrieval blocks direct gradient flow from the generator back to the retriever, which hinders true end-to-end joint learning and alignment of the retriever with downstream tasks.
    • The Salient Compressor Pretraining (SCP) stage uses synthetic QA pairs and paraphrases to train the compressor to distill documents into concise, semantically rich continuous "memory tokens" that preserve key information.
    • CLaRa integrates retrieval and generation within a single end-to-end differentiable framework by jointly training the query reasoner and generator with a language modeling loss and precomputed compressed document representations.
    • It uses a Straight-Through (ST) estimator to enable gradient flow through discrete top-k document selection, allowing the query reasoner to receive weak supervision from the generator's downstream task objective.
    AbstractPDF
  37. 095Code Generation / AgentsarXiv:2512.07921

    DeepCode: Open Agentic Coding

    • Existing LLM-based coding agents struggle with information overload and context bottlenecks when converting long, multimodal scientific papers into functional code repositories.
    • Common failure modes include preserving fragmented specifications, maintaining global consistency across modules, completing underspecified designs, and ensuring end-to-end execution fidelity.
    • Existing general-purpose and specialized scientific code agents have had limited success because their reproduction scores on autonomous software engineering tasks fall far short of human experts.
    • DeepCode adopts a multi-stage framework. Blueprint Generation reduces information overload by refining raw documents into structured specifications.
    • Code Generation uses CodeMem for stateful structural indexing of the evolving codebase to ensure global consistency, and CodeRAG for conditional knowledge injection from high-quality code corpora.
    • Automated Verification and Refinement integrates static analysis with sandbox execution feedback to perform closed-loop error correction, ensuring the functional fidelity of the synthesized repository.
    AbstractPDF
  38. 094Search Agents / EfficiencyarXiv:2511.17006

    Budget-Aware Tool-Use Enables Effective Agent Scaling

    • Standard tool-augmented LLM agents lack intrinsic budget awareness, so they use resources inefficiently and quickly hit performance limits even when the tool-use budget increases.
    • There was no systematic study or formal cost metric for jointly evaluating LLM token consumption and the economic cost of external tool interactions during agent test-time scaling.
    • Agents often explore too shallowly or stop early without strategically using the extra resources they have available, which leads to suboptimal results and wasted compute.
    • The authors developed Budget Tracker, a lightweight plug-and-play module that provides agents with real-time, continuous budget awareness through prompt-level policy guidance and state updates.
    • They introduced BATS, or Budget Aware Test-time Scaling, a training-free framework that dynamically adjusts planning, including constraint decomposition and structured dynamic planning, and self-verification strategies using continuous budget awareness.
    • They formalized a unified cost metric that comprehensively covers both internal LLM token consumption and the economic cost of external tool interactions, making scaling efficiency easier to evaluate transparently.
    AbstractPDF
  39. 093Agents / TheoryarXiv:2512.10047

    Detailed balance in large language model-driven agents

    • There is no unified theoretical framework for understanding the emergent behavior of large language model (LLM)-based agents at the macroscopic level.
    • The complex internal engineering of LLM agents often produces black-box behavior, making their dynamics hard to predict or analyze.
    • Current theoretical understanding of LLMs focuses mainly on microscopic token-level properties and does not explain emergent goal-directed agent behavior.
    • We formalize the generation process of LLMs inside agents as a Markov transition process over a defined state space.
    • We hypothesize an implicit potential function (VT) for LLMs and estimate it quantitatively using a minimum-action principle.
    • Experimental validation includes measuring transition probabilities between states generated by LLMs and statistically confirming detailed balance conditions across tasks and models.
    AbstractPDF
  40. 092Math Reasoning / BenchmarksarXiv:2511.01846

    Towards Robust Mathematical Reasoning

    • Existing mathematical reasoning benchmarks, such as GSM8K, MATH, and AIME, are approaching saturation, which limits their usefulness for distinguishing advanced model capability.
    • Many current benchmarks rely mainly on final-answer matching, which can let models guess or memorize answers without demonstrating robust multi-step reasoning.
    • There is a lack of a comprehensive evaluation framework for assessing deeper mathematical understanding, such as the ability to generate and rigorously evaluate proofs.
    • The paper introduces IMO-Bench, a comprehensive collection of three benchmarks: IMO-AnswerBench for robust problem solving, IMO-Proof Bench for rigorous proof writing, and IMO-GradingBench for proof evaluation.
    • IMO-AnswerBench uses 400 olympiad problems across four categories and applies explicit hardening techniques, such as paraphrasing and numerical changes, to prevent data memorization.
    • IMO-Proof Bench provides 60 IMO-level proof problems split into foundational and advanced sets, and it is evaluated mainly by human experts on a 0 to 7 scale that mimics traditional IMO grading.
    AbstractPDF
  41. 091Research AgentsarXiv:2510.17797

    Enterprise Deep Research: Steerable Multi-Agent Deep Research for Enterprise Analytics

    • Current autonomous agents lack domain specialization and seamless integration, making it difficult for enterprises to turn exponentially growing unstructured data into actionable insights.
    • Existing deep research systems are often opaque black boxes, lacking transparency, auditability, and real-time controllability, which makes them a poor fit for dynamic enterprise environments.
    • Most current systems are designed for open-domain web data and do not adequately handle heterogeneous, proprietary internal enterprise sources such as databases and files.
    • A modular multi-agent architecture coordinates a master research agent, specialized retrieval agents for the web, academic sources, GitHub, and LinkedIn, a visualization agent, and a Reflection mechanism for adaptive query decomposition and execution.
    • Through a Research Todo Manager that maintains a human-readable todo.md file, it introduces steerable context engineering, allowing real-time natural-language human intervention to dynamically adjust agent plans and priorities.
    • It uses an extensible Model Context Protocol (MCP)-based tool ecosystem to integrate domain-specific tools such as file analysis and NL2SQL agents, enabling reasoning over diverse proprietary enterprise data sources.
    AbstractPDF
  42. 090LLMs / ReasoningarXiv:2510.18855

    Every Step Evolves: Scaling Reinforcement Learning for Trillion-Scale Thinking Model

    • The lack of an open-source one-trillion-parameter thinking model has made advanced reasoning capabilities less accessible to the broader AI research community.
    • Scaling reinforcement learning (RL) to a one-trillion-parameter Mixture-of-Experts (MoE) model led to substantial instability caused by training-inference mismatch.
    • Inefficiencies in handling long reasoning trajectories and system bottlenecks in RL infrastructure created major challenges at an unprecedented scale.
    • They developed Ring-1T, a one-trillion-parameter MoE model trained through a multi-stage pipeline that includes Long Chain-of-Thought supervised fine-tuning and large-scale reinforcement learning.
    • They introduced IcePop, an RL algorithm variant that stabilizes training by suppressing noisy gradient updates through bilateral masking correction for probability drift.
    • They designed C3PO++ for efficient trajectory processing with dynamic, budget-controlled partitioning, and they built ASystem, a high-performance distributed RL infrastructure tuned for the trillion-parameter scale.
    AbstractPDF
  43. 089Reasoning / InferencearXiv:2510.14901

    Reasoning with Sampling: Your Base Model is Smarter Than You Think

    • It is unclear whether RL fundamentally teaches new reasoning capabilities to LLMs or simply sharpens already latent capabilities.
    • Current RL-based LLM post-training methods inherently require high compute cost, curated datasets, and external verifiers.
    • RL-post-trained models often suffer from diversity collapse, sacrificing multi-sample reasoning performance, pass@k, in favor of single-sample gains.
    • The base LLM's power distribution is defined by sampling from the original distribution raised to exponent α (α >= 1), which mathematically reweights the original distribution to favor higher-likelihood sequences.
    • The Metropolis-Hastings (MH) algorithm, a Markov chain Monte Carlo (MCMC) method, is used to enable approximate sampling from the unnormalized power distribution.
    • An iterative, blockwise autoregressive MCMC approach is introduced that progressively refines sequence segments, managing complexity and improving mixing time for long-sequence generation.
    AbstractPDF
  44. 088Continual LearningarXiv:2510.15103

    Continual Learning via Sparse Memory Finetuning

    • Large language models suffer from catastrophic forgetting, meaning they lose previously learned knowledge when updated with new information.
    • Current continual-learning methods for LLMs, such as replay-based and regularization-based approaches, are often compute-heavy, data-inefficient, or require trade-offs between new learning and retaining old knowledge.
    • LLMs are usually deployed as static models after training, which limits their ability to adapt to real-time information, user feedback, and changing world knowledge.
    • This paper proposes sparse memory fine-tuning, which uses a memory hierarchy where each token accesses only a small portion of a large memory pool.
    • It applies TF-IDF-like ranking scores to identify the most knowledge-specific memory indices in a new training batch, reducing interference with general knowledge.
    • During fine-tuning, only the top t memory indices identified by TF-IDF scores are updated, while all other memory parameters and the base LLM parameters remain fixed through gradient masking.
    AbstractPDF
  45. 087Vision / CompressionarXiv:2510.18234

    DeepSeek-OCR: Contexts Optical Compression

    • As input sequence length increases, LLMs face major compute and memory challenges because computation grows quadratically, limiting their ability to handle long text contexts.
    • Existing vision encoders in vision-language models (VLMs) suffer from limitations such as complex deployment, excessive image splitting, and high activation memory consumption for high-resolution documents.
    • Traditional OCR models did not explicitly address the optimal vision-text compression ratio or the minimum number of vision tokens needed for accurate text decoding when integrated with LLMs for long-context understanding.
    • DeepSeek-OCR is an end-to-end vision-language model composed of a new 380M-parameter DeepEncoder and a DeepSeek3B-MoE decoder.
    • DeepEncoder combines SAM-base and CLIP-large with a core 16x token compressor, a two-layer convolutional neural network, to efficiently process high-resolution images, reduce activation memory, and produce only a small number of vision tokens.
    • The model supports multiple resolution modes, including a dynamic "Gundam" mode that handles ultra-high-resolution inputs through tiling, and is trained on diverse datasets spanning traditional OCR, complex synthetic images such as charts, equations, and diagrams, and general vision data.
    AbstractPDF
  46. 086Benchmarks / AgentsarXiv:2508.15760

    LiveMCP-101: Stress Testing and Diagnosing MCP-enabled Agents on Challenging Queries

    • AI agents show promising prototype performance, but they lack reliability and robustness when deployed in real, dynamic operating environments.
    • Existing benchmarks for tool-augmented LLMs are limited because they evaluate only single-step tool calls, operate in synthetic environments, or focus on low task complexity, so they miss the complexity of real tool interaction.
    • There has been no clear framework for diagnosing the concrete failure modes of agents that handle diverse, time-varying external tools.
    • We constructed LiveMCP-101, a benchmark of 101 carefully selected real-world queries that require multi-step coordination across diverse MCP-enabled tools.
    • We propose a new evaluation methodology that uses gold execution plans and parallel live execution to reflect the dynamic and evolving nature of live MCP tool responses.
    • We use a human-expert-validated LLM-as-a-judge approach to provide fine-grained scoring for both final outputs and the agent's execution trajectory.
    AbstractPDF
  47. 085Reasoning / RL / SurveyarXiv:2509.08827

    A Survey of Reinforcement Learning for Large Reasoning Models

    • The rapid success of RL in transforming LLMs into LRMs faces substantial challenges related to compute, optimal algorithm design, and scalable high-quality training data.
    • Existing RL applications for LLMs have focused mainly on human alignment, overlooking RL's potential to fundamentally improve complex reasoning abilities.
    • The lack of a unified framework for understanding and navigating the complex, fast-moving landscape of RL for reasoning models hinders systematic research and development.
    • The authors conduct a comprehensive literature review and organize the field into its foundational components: reward design, policy optimization, and sampling strategies.
    • The survey introduces and highlights reinforcement learning with verifiable rewards, or RLVR, as a key paradigm for strengthening reasoning on tasks with objective feedback.
    • It clarifies and discusses foundational questions and ongoing debates, such as RL's role in sharpening versus discovering reasoning and the interaction between RL and supervised fine-tuning, or SFT.
    AbstractPDF
  48. 084Multi-Agent / DebatearXiv:2509.05396

    Talk Isn't Always Cheap: Understanding Failure Modes in Multi-Agent Debate

    • There is a common belief that multi-agent debate universally improves large language model performance on complex reasoning tasks.
    • There is still a limited understanding of the specific failure modes that arise when multiple LLMs interact, especially in heterogeneous groups with varied capabilities.
    • It is necessary to clarify when and why multi-agent debate can be harmful rather than beneficial.
    • The authors used a standard multi-agent debate framework in which LLMs iteratively revise their responses over multiple rounds based on peer input.
    • They conducted an empirical study with heterogeneous groups of three LLMs, GPT-4o-mini, LLaMA-3.1-8B-Instruct, and Mistral-7B-Instruct-v0.2, across three datasets, CommonSenseQA, MMLU, and GSM8K.
    • They analyzed failure patterns through sequential revision traces, social influence evaluation using the probability of answer flipping after peer agreement, and interventions designed to reduce sycophancy.
    AbstractPDF
  49. 083Agents / RLarXiv:2509.08755

    AgentGym-RL: Training LLM Agents for Long-Horizon Decision Making through Multi-Turn Reinforcement Learning

    • There is no integrated, interactive reinforcement learning (RL) framework that can train LLM agents from scratch for complex, multi-turn, long-horizon tasks.
    • Existing methods for developing LLM agents, such as prompting and supervised fine-tuning (SFT), often rely on proprietary models or human-curated data, limiting scalability, adaptability, and intrinsic self-improvement.
    • Traditional RL applications to LLMs are mostly limited to single-turn tasks or face instability and inefficiency when extended to multi-turn agentic decision making.
    • AgentGym-RL is a modular open-source framework that separates the environment, agent, and training modules to support diverse multi-turn long-horizon tasks.
    • ScalingInter-RL is a new progressive interactive scaling strategy that adaptively increases the maximum number of turns during RL training to balance exploration and exploitation while improving optimization stability and efficiency.
    • The framework integrates a full RL pipeline that supports mainstream online RL algorithms such as PPO and GRPO, with engineering optimizations for scalability and reliability across a variety of realistic environments.
    AbstractPDF
  50. 082Reasoning / ParallelismarXiv:2509.04475

    ParaThinker: Native Parallel Thinking as a New Paradigm to Scale LLM Test-time Compute

    • Sequential LLM reasoning shows tunnel vision, where early mistakes cause diminishing returns and stagnation even as compute increases.
    • Current depth-scaling approaches become inefficient beyond a certain point and fail to unlock further gains on complex reasoning tasks.
    • Existing parallel or search-based methods often depend on external verifiers or domain-specific components, or they add substantial extra compute.
    • ParaThinker uses a two-stage process: parallel reasoning that generates multiple independent thought paths, followed by summarization that integrates those paths into a single final answer.
    • It uses special control tokens, `think i` and `summary`, to guide the model in generating diverse reasoning paths and then merging them.
    • Thought-specific positional embeddings augment standard RoPE to resolve positional ambiguity across parallel paths, ensuring distinct processing and effective summarization.
    AbstractPDF