HDATF
English
Start a conversation
Menu

Paper Archive

Every archived paper with its summary, highest number first.

Papers 1,193Archive updated BenchmarksRSS feed
  1. 144Agents / ResearcharXiv:2604.13018

    Toward Autonomous Long-Horizon Engineering for ML Research

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

    LightThinker++: From Reasoning Compression to Memory Management

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

    MedGemma 1.5 Technical Report

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

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

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

    Scaling Coding Agents via Atomic Skills

    • Current LLM coding agents are trained mainly on composite benchmarks such as bug fixing, which often leads to task-specific overfitting and limited generalization.
    • To address this, the authors propose a new scaling paradigm that shifts the focus from task-level optimization to mastery of atomic skills.
    • They first formalize five fundamental atomic skills that act as basis vectors for complex software engineering tasks: code localization, code editing, unit test generation, issue reproduction, and code review.
    • Compared with composite coding tasks, these atomic skills are more generalizable and composable.
    • The next step is to scale coding agents by performing joint RL on the atomic skills.
    • In this way, the atomic skills improve consistently without negative interference or trade-offs between them.
    AbstractPDF
  6. 139Agents / EvaluationarXiv:2604.06240

    The Art of Building Verifiers for Computer Use Agents

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

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

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

    Memory Intelligence Agent

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

    Neural Computers

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

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

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

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

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

    Self-Organizing LLM Agents

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

    Coding Agents are Effective Long-Context Processors

    • The method is to represent long documents and large corpora as navigable files and directories, then let the coding agent choose executable operations such as grep, sed, Python aggregation, and note files.
    • The core idea is that long-context reasoning becomes environment interaction, so the model no longer needs to compress everything into latent attention or a single retrieved snippet.
    • As a result, it reports an average improvement of 17.3 percent over the previous best published system, achieves SOTA on four of five benchmarks, and shows strong scaling from 188K-token context to a 3-trillion-token Wikipedia corpus.
    • The limitation and implication are that this approach depends on the agent's tool capabilities and on data organization, and that naive retriever addition can suppress useful exploration, so future systems need retrieval that complements rather than replaces filesystem search.
    AbstractPDF
  14. 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
  15. 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
  16. 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
  17. 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
  18. 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
  19. 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
  20. 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
  21. 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
  22. 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
  23. 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
  24. 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
  25. 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
  26. 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
  27. 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
  28. 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
  29. 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
  30. 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
  31. 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
  32. 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
  33. 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
  34. 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
  35. 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
  36. 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
  37. 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
  38. 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
  39. 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
  40. 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
  41. 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
  42. 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
  43. 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
  44. 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
  45. 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
  46. 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
  47. 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
  48. 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
  49. 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
  50. 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