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.
- 69Security / Agents
From Prompt Injections to Protocol Exploits: Threats in LLM-Powered AI Agents Workflows
- The rapid spread of LLM-based AI agents and their complex ecosystems lacks standardized, robust security practices, leading to widespread vulnerabilities.
- Current integrations often rely on ad hoc authentication and weak verification mechanisms, making them highly vulnerable to many forms of exploitation.
- Existing security research on LLM agents is fragmented and has not provided a unified end-to-end framework that covers threats across the full communication stack, from host-to-tool interactions to agent-to-agent interactions.
- A unified end-to-end threat model was developed that systematically analyzes security risks across the entire LLM agent ecosystem, including host-to-tool and agent-to-agent communication.
- More than 30 different attack techniques were classified into four major areas: input manipulation, model corruption, system and privacy attacks, and protocol vulnerabilities.
- Rigorous mathematical formulations were provided for each threat category, explicitly defining attacker capabilities, goals, and affected layers to enable systematic analysis.
- 68RAG / Agents
ARAG: Agentic Retrieval Augmented Generation for Personalized Recommendation
- Existing RAG systems for personalized recommendation rely on simple retrieval mechanisms, such as cosine similarity, that fail to capture nuanced user preferences.
- Existing RAG methods struggle to understand implicit preferences, process long-form user documents, and dynamically rank items based on multifaceted contextual factors.
- Using LLMs directly for recommendation is computationally expensive, prone to hallucination, and constrained by fixed knowledge cutoffs, so robust grounding is needed.
- ARAG proposes a multi-agent framework in which specialized LLM agents collaborate to refine context retrieval and item ranking for personalized recommendation.
- It uses a User Understanding Agent (UUA), a Natural Language Inference (NLI) agent, a Context Summarization Agent (CSA), and an Item Ranking Agent (IRA) to decompose the complex recommendation task.
- The agents operate in a blackboard-style collaboration, with UUA and NLI running in parallel, followed by CSA and then IRA, to synthesize user preferences and align them with candidate items.
- 67Scientific AI / Survey
AI4Research: A Survey of Artificial Intelligence for Scientific Research
- Despite rapid progress in large language models and their scientific innovation applications, there has been no comprehensive and systematic survey that specifically covers the full cycle of scientific research, AI4Research.
- Existing surveys usually focus on narrower subareas such as AI for scientific discovery, which has fragmented understanding of AI's broader impact on academic workflows.
- The lack of an integrated perspective hinders systematic understanding and slows further progress in using AI across all stages of scientific research.
- The authors developed a taxonomy that categorizes AI applications into five major tasks across the research cycle: scientific understanding, academic surveying, scientific discovery, academic writing, and academic peer review.
- They formally defined AI4Research and distinguished it from the narrower AI4Science, while providing a rigorous component-level framework for understanding AI's role at each stage.
- For each component, they conducted an extensive literature review to synthesize current methods, pioneering work, and empirical summaries, and they also organized practical resources such as tools, datasets, and benchmarks.
- 66Agents / SLMs
Small Language Models are the Future of Agentic AI
- The current dominant LLM-centric paradigm for AI agents carries high economic cost because reasoning demands enormous compute.
- General-purpose LLMs are operationally inefficient and add latency when they perform the repetitive, specialized sub-tasks common in agentic workflows.
- The large energy consumption associated with LLMs raises sustainability concerns, and they often lack precise specialization for narrow agentic tasks.
- This paper proposes a paradigm shift to specialized small language models as the primary compute unit for most agentic calls.
- It advocates a heterogeneous agent architecture that uses SLMs for routine and specialized tasks and reserves LLMs for complex general reasoning.
- It provides a practical six-step algorithm for converting LLM-centric agent applications into SLM specialists, including data collection, task clustering, fine-tuning, and continual improvement.
- 65Reasoning / Small Models
Tina: Tiny Reasoning Models via LoRA
- Achieving robust multi-step reasoning in large language models remains a major challenge.
- Current LLM reasoning enhancement methods, such as supervised fine-tuning and reinforcement learning, are resource-intensive and often require substantial compute and large models.
- The high cost and complexity of RL pipelines limit both accessibility and broad research on RL-based reasoning for language models.
- It uses the small 1.5-billion-parameter base model DeepSeek-R1-Distill-Qwen-1.5B, which is known for its initial reasoning aptitude.
- It applies Low-Rank Adaptation (LoRA) for parameter-efficient reinforcement learning with a GRPO-style algorithm, updating only a subset of the model parameters.
- To ensure cost efficiency and direct comparability with existing models, it uses a minimalist training setup with two NVIDIA L40S GPUs and public reasoning datasets.
- 64RL / Inference
TTRL: Test-Time Reinforcement Learning
- Applying reinforcement learning to reasoning tasks for large language models is bottlenecked by the high cost and scarcity of human-annotated ground-truth labels needed for reward estimation.
- Existing RL methods for LLMs rely heavily on supervised reward signals, which makes it difficult to keep improving on newly encountered or unlabeled test data.
- The lack of explicit reward signals at inference time limits an LLM's ability to adapt to new distributions and improve generalization without human intervention.
- It introduces Test-Time Reinforcement Learning, or TTRL, a framework that lets an LLM update its parameters and improve generalization at test time using RL.
- It generates reward signals without explicit ground-truth labels by repeatedly sampling model outputs and deriving a consensus output through majority vote.
- It computes a rule-based binary reward from whether each sampled output matches the majority-vote pseudo-label, and uses it to optimize the model policy with an RL algorithm such as GRPO.
- 63Vision-Language
Describe Anything: Detailed Localized Image and Video Captioning
- Existing vision-language models struggle to generate detailed and accurate captions for specific regions in images and videos.
- High-quality datasets for training detailed local captioning models are limited.
- Current evaluation metrics often rely on reference captions that lack comprehensive detail.
- It developed the DAM architecture for multi-granularity region captioning, with focal prompts and a localized vision backbone.
- It built the SSL-based data pipeline DLC-SDP using segmentation datasets and unlabeled web images.
- It introduced DLC-Bench for evaluating detailed local captions without reference captions.
- 62GUI Agents
UI-TARS: Pioneering Automated GUI Interaction with Native Agents
- Existing GUI agents rely heavily on text-based representations and modular frameworks, which limit scalability.
- There is a lack of large, high-quality data for training end-to-end GUI agents.
- Complex GUI scenarios require advanced perception, reasoning, and coordination capabilities that current approaches do not have.
- We developed UI-TARS, an end-to-end model that interacts with interfaces by processing screenshots directly.
- We built large-scale datasets for perception, grounding, and action traces through automatic collection and curation.
- We integrated System 2 reasoning through thought augmentation and reflection tuning.
- 61LLMs / Efficiency
BitNet b1.58 2B4T Technical Report
- Large language models are compute-intensive, requiring substantial memory and energy and causing high latency.
- These resource demands constrain LLM deployment on edge devices and in real-time applications.
- Previous 1-bit quantization methods either hurt performance, as in post-training quantization, or failed to scale to competitive model sizes.
- It implements a modified Transformer architecture with custom BitLinear layers for 1.58-bit weights and 8-bit activations.
- It uses a multi-stage training approach that begins with an unprecedented 4 trillion-token pretraining run and continues with supervised fine-tuning and Direct Preference Optimization.
- It develops and open-sources a specialized inference library with custom kernels for efficient W1.58A8 operations on both GPUs and CPUs.
- 60Reasoning / RL
Does Reinforcement Learning Really Incentivize Reasoning Capacity in LLMs Beyond the Base Model?
- It is commonly believed that, like traditional RL discovering new strategies, RLVR gives LLMs new reasoning abilities.
- No rigorous study has determined whether current RLVR truly expands the range of problems LLMs can solve or merely optimizes sampling of existing solutions.
- Traditional evaluation metrics often fail to capture an LLM's full reasoning potential or its reasoning capability boundary.
- Pass@k is introduced as a robust metric that defines the LLM's reasoning capability boundary by measuring the fraction of problems solvable within k attempts.
- The study systematically evaluates reasoning ability across diverse LLM families, sizes, multiple RL algorithms such as PPO and GRPO, and task domains such as math, code, and visual reasoning.
- Deep analysis methods, including perplexity analysis and solvable-problem coverage, are used to determine whether RLVR-generated reasoning paths are genuinely novel or already lie within the base model's distribution.
- 59Architecture / Training
NoProp: Training Neural Networks without Full Back-propagation or Full Forward-propagation
- Traditional backpropagation is not biologically plausible because of the weight transport problem and the need to synchronize forward and backward passes.
- Full backpropagation requires storing intermediate activations, which creates substantial memory overhead and limits true parallelization across network layers because of sequential dependencies.
- The global error signal and sequential credit assignment in backpropagation can cause problems such as catastrophic forgetting and interference in lifelong learning settings.
- It introduces NoProp, a block-wise neural network learning method inspired by denoising diffusion and flow matching models.
- Each network block independently learns to denoise a noisy version of the target label using local backpropagation only within that block.
- It broadcasts the input and target labels to all blocks, allowing each block to optimize its objective independently without global error-signal propagation.
- 58Agents / Self-Awareness
Agentic Knowledgeable Self-awareness
- Current LLM agents lack situational self-awareness, so they use cognitive resources such as reflection and external knowledge in a scattered and inefficient way.
- Existing agent training methods are vulnerable to unexpected signals, prone to pattern collapse, and often incur high reasoning costs because they rely on a one-size-fits-all approach.
- Agents also struggle to assess their own abilities dynamically in complex and changing environments, which leads to suboptimal decisions.
- KnowSelf introduces a three-stage situational classification scheme, Fast, Slow, and Knowledgeable Thinking, to determine an agent's real-time cognitive resource needs.
- It builds a lightweight offline knowledge system and generates self-awareness data by appending special tokens that indicate the type of thinking required for the trajectories the agent explored.
- A two-stage fine-tuning process, SFT and RPO, teaches agents to connect situational cues with the right cognitive response, enabling them to activate reflection or external knowledge dynamically during inference.
- 57Knowledge Graphs / LLMs
LightPROF: A Lightweight Reasoning Framework for Large Language Model on Knowledge Graph
- Existing KG-enhanced LLM approaches rely on large, computationally expensive models and complex KG traversal strategies.
- Current methods do not exploit structural information in knowledge graphs effectively, which leads to redundant information and inaccurate reasoning.
- It is a three-module framework that combines reasoning-graph retrieval, knowledge embedding through a small Transformer adapter, and mixed-prompt reasoning.
- It is a parameter-efficient training method that freezes the LLM parameters and updates only the Knowledge Adapter.
- It improves knowledge integration by converting both text content and graph structure into embeddings that are used as soft prompts.
- It uses constrained breadth-first search with LLM-based scoring to retrieve relevant reasoning paths in the knowledge graph.
- 56Pre-training / Reasoning
Rethinking Reflection in Pre-Training
- There is a common belief that complex cognitive abilities such as reflection in large language models emerge mainly during post-training stages like fine-tuning and reinforcement learning.
- There is no systematic, scalable method for measuring reflection across different stages of pretraining.
- Benchmarking reflection with standard reasoning datasets is difficult because reflective behavior is rare and error patterns are diverse.
- To provide a finer-grained measurement framework, it defines multiple dimensions of reflection: situational, self, explicit, and implicit.
- To systematically elicit and measure reflection by introducing human-like errors into reasoning chains, it develops a programmatic method for generating adversarial chain-of-thought datasets.
- It uses a prompt-based LLM classifier to detect explicit reflection and measures four key metrics: accuracy, explicit reflection rate, explicit reflection accuracy, and implicit reflection accuracy.
- 55Reasoning / Efficiency
Concise Reasoning via Reinforcement Learning
- Large language models strengthened for reasoning tasks through reinforcement learning, or RL, tend to produce excessively verbose chain-of-thought outputs, which increases compute cost and inference latency.
- The prior literature contains conflicting observations about whether response length is necessary for reasoning accuracy, with some studies finding that longer responses improve accuracy while others observe diminishing returns.
- The fundamental mechanism by which RL training affects response length, and whether this verbosity is an essential part of reasoning or merely a byproduct, is not well understood.
- The paper casts reasoning as a Markov decision process and performs a theoretical analysis of the loss dynamics of Proximal Policy Optimization, or PPO, and Generalized Reinforcement Learning with Policy Optimization, or GRPO, to explain how negative rewards push the policy toward verbosity.
- It proposes a new two-stage RL training procedure that first strengthens reasoning on hard problems and then explicitly enforces conciseness on a small dataset of problems that are sometimes solvable.
- It uses a built-in property of PPO, with generalized advantage estimation lambda below 1, where positive rewards encourage shorter responses and negative rewards encourage longer ones, to guide the model toward conciseness without sacrificing accuracy.
- 54Interpretability
OLMoTrace: Tracing Language Model Outputs Back to Trillions of Training Tokens
- LLMs behave as black boxes, making it hard to understand why they produce specific outputs.
- Existing interpretability methods such as influence functions are computationally intractable at the trillions-of-token scale of modern LLM training datasets.
- The lack of tools to efficiently analyze memorization in LLMs, trace factual claims back to sources, or identify the origins of generated text raises concerns about transparency, copyright, and PII.
- OLMoTrace developed a system that uses an expanded infini-gram index to efficiently find maximal exact-match spans within a trillion-token-scale training dataset.
- The method has five stages: identify maximal matching spans, filter long and unique spans, retrieve containing documents, merge duplicates, and rerank documents by relevance using BM25.
- The production system uses high-IOPS SSDs on Google Cloud to guarantee the disk I/O throughput needed for real-time performance on large-scale data.
- 53Reasoning / Survey
Harnessing the Reasoning Economy: A Survey of Efficient Reasoning for Large Language Models
- Current LLMs show inefficient reasoning behaviors such as excessive computation and unnecessary deliberation.
- There is a lack of systematic understanding of how to optimize the tradeoff between reasoning ability and compute cost.
- The survey develops a structured framework that classifies reasoning inefficiency and potential solutions.
- It classifies optimization approaches into behavior regulation after training and usage improvement at test time.
- Reasoning inefficiency arises from both model behavior, such as length bias and deceptive thinking, and model usage, such as poor algorithm choice and compute allocation.
- The proposed solutions should address both post-training factors, such as data quality and structure, and test-time strategies such as budget allocation and adaptive decoding.
- 52Reasoning / Efficiency
Z1: Efficient Test-time Scaling with Code
- Large language models consume too many tokens during reasoning tasks, even on simple problems that do not need elaborate thinking steps.
- Prior approaches lack an efficient way to scale test-time reasoning while controlling token usage.
- The model is fine-tuned on a carefully selected code reasoning dataset of 107K examples with balanced short and long trajectories.
- The method implements a Shifted Thinking Window that limits reasoning tokens and forces a direct answer once the threshold is exceeded.
- It removes context separators so that reasoning depth can be adjusted more flexibly.
- The results suggest that longer reasoning trajectories and larger dataset scale are key to eliciting effective reasoning.
- 51Search / Agents
Open Deep Search: Democratizing Search with Open-source Reasoning Agents
- Existing proprietary search AI solutions limit transparency, innovation, and community-driven development.
- Current open-source search tools lack sophisticated query processing and contextual retrieval capabilities.
- It presents Open Search Tool, which includes query reformulation, advanced retrieval, and context augmentation.
- It presents two reasoning agent architectures, ReAct and CodeAct, that interpret queries and coordinate tool use.
- It is a plug-and-play framework that can integrate with any underlying language model.
- Adaptive web search based on result quality improves both efficiency and accuracy.
- 50Interpretability
Why do LLMs attend to the first token?
- The persistent, unexplained phenomenon in which large language models disproportionately attend to the first token, called an attention sink, lacked a functional explanation.
- Information degradation in deep Transformers, including rank collapse, representation collapse, and over-squashing, causes loss of individual token information, especially in long sequences.
- Prior literature did not provide a fundamental understanding of why attention sinks occur or what functional purpose they serve.
- This paper theoretically connects attention sinks to excessive mixing and representation collapse, and derives a new over-squashing bound that quantifies how sinks regulate information flow.
- We performed extensive empirical validation on state-of-the-art LLMs Gemma 7B and the LLaMa 3.1 family through perturbation analysis, close inspection of attention patterns, and targeted ablation studies.
- Controlled pretraining experiments demonstrated a causal relationship between context length, model scale, and the formation and strength of attention sinks.
- 49Medical AI / RAG
RARE: Retrieval-Augmented Reasoning Modeling
- LLMs exhibit knowledge hallucination and insufficient reasoning ability in specialized domains.
- Existing approaches such as RAG mainly supplement knowledge at inference time and do not systematically train domain-specific reasoning during learning.
- Conventional fine-tuning or pretraining for domain knowledge is costly, causes knowledge entanglement, and remains vulnerable to hallucination because of parameter budget limits.
- It externalizes domain knowledge into searchable sources and internalizes domain-specific reasoning patterns inside the LLM.
- It distills high-quality step-by-step reasoning responses that include retrieved knowledge using a teacher model.
- It trains a lightweight student model with a masked-loss objective that injects retrieved knowledge into the prompt, forcing the model to focus on integrating the provided information and reasoning from it.
- 48Research Agents
CodeScientist: End-to-End Semi-Automated Scientific Discovery with Code-based Experimentation
- Existing autonomous scientific discovery, or ASD, systems often focus on only part of the research pipeline or rely on domain-specific languages, which limits the range of possible discoveries.
- There is a need for an end-to-end semi-automated system that uses large language models for scientific discovery while emphasizing code-based experimentation.
- Evaluating the reliability and reproducibility of discoveries made by LLM-based ASD systems is difficult because of the inherent variability of language model outputs and the potential unreliability of generated code.
- CODESCIENTIST implements a semi-automated end-to-end scientific discovery workflow consisting of ideation, planning, experiment design and execution, reporting, and meta-analysis.
- It uses a mutator-style LLM genetic search approach for ideation, combining fragments of research papers and code blocks to generate diverse research ideas.
- The system generates and runs code in an instrumented sandbox, uses iterative generate run reflect debug loops, and performs multiple independent executions for each experiment to ensure reproducibility.
- 47LLMs / Enterprise
Command A: An Enterprise-Ready Large Language Model
- General-purpose LLMs often lack optimization for enterprise workflows such as retrieval-augmented generation, complex agentic tasks, and robust multilingual support.
- Deploying state-of-the-art LLMs in enterprise settings is often compute-intensive and expensive, which hinders on-premise or privacy-preserving deployment.
- Integrating diverse capabilities into a single LLM without catastrophic forgetting or performance tradeoffs remains a major challenge in large-scale model training.
- Command A balances efficiency and performance with a decoder-only Transformer that uses a new hybrid attention mechanism and Grouped-Query Attention.
- Its distributed post-training approach trains six specialized expert models, such as Code, Safety, and RAG, on domain-specific data and then merges their parameters into a unified soup model with integrated capabilities.
- The refinement stage integrates advanced supervised fine-tuning and reinforcement-learning techniques, including Self-improving Robust Preference Optimization and online RLHF for human alignment and specific abilities.
- 46Benchmarks / Research Agents
PaperBench: Evaluating AI's Ability to Replicate AI Research
- Existing AI agent benchmarks are often too narrow and too simple to evaluate performance on long-horizon, open-ended machine learning R&D tasks.
- In particular, safety and governance frameworks need rigorous, objective, and scalable measures of an AI model's autonomy and ability to conduct scientific research.
- Human reproduction of research papers is time-consuming and subjective, which makes it hard to scale for consistent evaluation of AI agents.
- OpenAI researchers introduced PaperBench, a benchmark of 20 recent ICML papers that requires AI agents to reproduce empirical results from scratch without access to the original codebase.
- For each paper, a detailed hierarchical rubric developed with the original authors provides binary pass or fail criteria across 8,316 specific contribution items.
- SimpleJudge, an LLM-based automatic judge validated at an F1 score of 0.83 against human grading benchmark JudgeEval, provides scalable and consistent evaluation of agent submissions.
- 45Image Generation
Fractal Generative Models
- Traditional generative models struggle with the computational burden and artificial sequentialization required by high-dimensional, non-sequential data such as raw images.
- Achieving high-fidelity pixel-level image generation at high resolution is computationally infeasible and difficult because of the enormous dimensionality.
- Modularity in existing deep learning is often limited to layers or simple blocks, leaving it without the higher-level abstractions needed to compose full generative models.
- It proposes a new generative modeling paradigm, 'fractal generative models,' that recursively calls existing generative models as atomic generation modules to form self-similar structures.
- The framework is instantiated as autoregressive (AR) models for pixel-level image generation, FractalAR and FractalMAR, using a divide-and-conquer strategy over image patches.
- At each hierarchical level, it uses multi-scale patching and local attention mechanisms to greatly reduce the quadratic computational cost of high-resolution image generation.
- 44RL / Agents
Agentic Reward Modeling: Integrating Human Preferences with Verifiable Correctness Signals for Reliable Reward Systems
- Existing reward models rely too heavily on human preferences, which can introduce bias and accuracy problems.
- Current approaches lack systematic verification of factual accuracy and instruction following.
- Traditional reward models often fail to capture multiple important evaluation criteria at the same time.
- The authors developed a multi-agent reward system that combines specialized verification agents with human preference signals.
- They built a router component that intelligently decides which verification agents to call.
- They also implemented a unified mechanism that combines scores from multiple evaluation sources.
- 43Math Reasoning
LADDER: Self-Improving LLMs Through Recursive Problem Decomposition
- Reinforcement learning for large language models (LLMs) requires a progressive curriculum of difficulty in the training tasks, but that is often unavailable and leads to training stagnation or catastrophic performance collapse.
- Complex reasoning domains such as mathematics pose a substantial challenge because there is a large gap between problems the model can solve and those it cannot solve yet.
- Existing LLM training and improvement methods often rely heavily on large human-curated datasets or continuous human supervision and feedback.
- The LADDER framework enables recursive problem decomposition, allowing the LLM to autonomously generate a tree of progressively simpler variants of a complex problem it cannot currently solve, using transformation libraries and induced prompting.
- A robust numerical verification framework evaluates answer correctness and provides a clear, objective reward signal for reinforcement learning.
- Test-Time Reinforcement Learning (TTRL) extends LADDER by generating problem-specific focused variants at inference time for previously unsolved test problems, enabling targeted and dynamic learning on individual hard questions.
- 42Alignment / Safety
Forecasting Rare Language Model Behaviors
- Standard LLM evaluations cover thousands of queries, but deployed models process billions, leaving a significant blind spot for rare but potentially harmful behaviors.
- Behavior that appears safe in limited tests can create substantial risk when exposed to far more queries in deployment.
- Traditional evaluation methods do not account for the fundamental scale gap or the stochastic nature of language models, which can generate different answers to the same query.
- Researchers from Anthropic, Mila, and UC Berkeley developed a Gumbel-tail method to predict the risk of undesirable LLM behavior at deployment scale using limited evaluation data.
- The method estimates each query's trigger probability by repeatedly sampling the model and measuring the fraction of responses that exhibit the target behavior.
- It uses extreme value theory, specifically the Gumbel distribution, to model and extrapolate the tail behavior of these trigger probabilities from a small set of evaluation queries.
- 41Reasoning / RL
Cognitive Behaviors that Enable Self-Improving Reasoners, or, Four Habits of Highly Effective STaRs
- Some large language models achieve substantial self-improvement through reinforcement learning on verifiable reasoning tasks, while others quickly plateau under the same training.
- It remained unclear which intrinsic properties or early capabilities enable LLMs to use extra compute effectively for self-improvement.
- There was limited understanding of the foundational traits that determine success or failure in RL-based self-improvement for LLM reasoning.
- The team developed a framework that uses a GPT-4o-mini classifier to identify and quantify four cognitive behaviors in LLM reasoning traces: verification, backtracking, subgoal setting, and reverse chaining.
- They ran comparative RL experiments on models with different self-improvement abilities, Qwen-2.5-3B and Llama-3.2-3B, in the Countdown game.
- They induced self-improvement with targeted interventions, such as fine-tuning models on synthetic data rich in specific cognitive behaviors and curating pretraining data to amplify those behaviors.
- 40Reasoning / Survey
LLM Post-Training: A Deep Dive into Reasoning Large Language Models
- Pretrained large language models (LLMs) often struggle with factual accuracy and produce hallucinated or logically inconsistent outputs.
- LLM reasoning is primarily based on statistical patterns rather than explicit logical inference, which limits performance on complex reasoning tasks.
- Despite massive pretraining, LLMs may still be misaligned with human intent, preferences, and ethical considerations, so additional refinement is needed for trustworthy deployment.
- This paper systematically surveys and categorizes existing post-training methodologies for LLMs, with a focus on their role in improving reasoning ability.
- It organizes these techniques into three connected stages: fine-tuning (for example, instruction, CoT, PEFT), reinforcement learning (for example, RLHF, DPO, RLAIF), and test-time scaling (for example, CoT prompting, Tree-of-Thoughts, MCTS).
- The survey highlights the specific points at which each technique helps refine LLM behavior, improve robustness, and ensure adaptability across applications.
From research to product use
Operating capabilities, pilots, and technologies in development are identified separately.
View technology