Research library
Search papers on equipment connectivity, quality inspection, production analysis, and manufacturing work.
Search and filter
New paper summaries
Summaries are editorial notes, not statements by the original authors. Check the original paper. Updated 2026-11-20.
- 129Agents / Metacognition
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.
- 128Multimodal / Reasoning
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.
- 127Agents / Architecture
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.
- 126Memory / Agents
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.
- 125Math Reasoning / Formal Proofs
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.
- 124Multi-Agent
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.
- 123Interpretability
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.
- 122Reasoning / Probabilistic
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.
- 121Brain-Computer Interface / Agents
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.
- 120Scientific AI
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.
- 119Agents / Architecture
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.
- 118RAG / Agents
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.
- 117Memory / Long Context
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.
- 116Multi-Agent / Routing
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.
- 115Memory / Agents
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.
- 114Fine-tuning / Efficiency
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.
- 113Math / Scientific AI
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.
- 112Memory / RL / Agents
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.
- 111Memory / Agents
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.
- 110Evaluation / Agents
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.
- 109Memory / Efficiency
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.
- 108Memory / Agents
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.
- 107Agents / Search
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.
- 106World Models
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.
- 105Architecture / Learning
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.
- 104Benchmarks / Code
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.
- 103Scientific AI / RL
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.
- 102RL / Training
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.
- 101Security / Code
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.
- 100Architecture
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.
From research to product use
Operating capabilities, pilots, and technologies in development are identified separately.
View technology