Papers for

enterprise ai platform teams

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Selective cache reconstruction speeds up distributed large language model inference

RISK-KV: Quality-Aware Selective KV Cache Reconstruction for Distributed LLM Inference

Abstract: Request migration and interruption recovery in distributed large language model (LLM) inference rely on historical key-value (KV) caches. Retaining or transferring a complete cache incurs substantial state overhead, whereas replaying historical tokens requires additional computation. This paper proposes RISK-KV, a quality-aware method for selective historical KV reconstruction in pretrained models. RISK-KV uses exact KV states on both sides of a target layer and cross-layer ridge regression to predict the missing layer's attention-projection input; it then folds in the original model's KV projection matrices to reduce predictor storage. Reconstruction risk is measured by the change in negative log-likelihood (NLL) caused by actual reconstruction, and low-overhead topology search with quality gating selects the layer groups to reconstruct. Independent tests on three language models show that representative recovery configurations omit 18.2 percent to 33.3 percent of historical KV, with perplexity changes below 0.5 percent. In a local request-recovery experiment with a 512-token history, RISK-KV achieves a 1.51 to 3.31 times speedup over full Token Replay. These results indicate that selective KV reconstruction can reduce historical cache overhead with small changes in predictive quality and improve request-recovery efficiency under the evaluated deployment conditions.

Wed 21 OctDistributed, Parallel, and Cluster Computing
The gist
Using large language models (LLMs) often requires keeping track of previous information, which can be very heavy to store or slow to recompute. This paper presents a method called RISK-KV that smartly chooses parts of this stored information to rebuild, instead of keeping or recalculating everything. The authors show this approach reduces storage and speeds up processing while keeping the model’s predictions almost as good as before. Their tests demonstrate it works well across different LLMs and practical scenarios.
Open → 2610.29544v1

Consolidating specialist AI models with no retraining needed

Training-Free On-Policy Distillation

Abstract: On-policy distillation consolidates specialist models into one student at the price of rollouts, teacher passes and gradient steps for every teacher. We show that the consolidation does not need training: with forward passes only, the capabilities of separately tuned specialists can be aggregated into one model that is, on average, more accurate than either specialist alone. When specialists share a base model, distillation has an exact layer-wise solution: each linear layer of the fused model must reproduce every specialist's output on the inputs that specialist receives while reading its own answers, a least-squares problem whose solution needs only the second moments of those inputs. One forward pass over a few hundred rollouts provides them. We call this training-free on-policy distillation (\method). What the rollouts contain matters more than the solver: answers truncated in repetition loops are few among a mathematics specialist's rollouts but carry a large share of their tokens, and removing them lifts the fused model on AIME25 from task arithmetic's level to the specialist's at matched precision. On Olmo~3 7B, a few GPU-hours of forward computation per specialist yield a generalist that keeps most of each specialist's gain on each of seven mathematics and code benchmarks.

Thu 15 OctMachine LearningArtificial IntelligenceComputation and Language
The gist
Combining AI models that are experts in different areas usually requires lots of retraining. This paper shows that by simply running these models on some example tasks and doing a special calculation, you can merge their strengths into one model without training. The combined model can perform better on average than the individual experts alone. The key trick is using a mathematical solution that matches each expert's responses layer by layer, based on data from their normal use.
Open → 2610.22236v1

AutoAdapt enables efficient domain updates with modular adapters

AutoAdapt: Automatic Domain Discovery Enables Low-Cost Extensibility

Abstract: Instruction-tuned models are deployed into environments where domains are heterogeneous and evolve, yet adding new domains or data typically requires costly retraining. We present AutoAdapt, a modular framework that incorporates new domains and data via targeted single-adapter training without modifying other adapters. The framework automatically discovers latent domains, uses them to train per-domain Low-Rank Adaptation (LoRA) adapters independently in parallel and performs parameter-free routing. Across 14 domain-specific benchmarks and GPT-4o pairwise judgements, AutoAdapt achieves parity with a LoRA adapter trained on all domains without requiring full-model retraining. We also find evidence of specialisation effect convergence across independent discovery methods. Overall, training each adapter on its own domain prevents domain interference by construction, thus enabling modular, taxonomy-free domain specialisation without aggregate performance loss or full model retraining.

Wed 7 OctMachine Learning
The gist
Instruction-tuned AI models often work with many different types of tasks or topics, which can change over time. The paper presents AutoAdapt, a way to add new topics or domains without retraining the entire model by training small separate modules called adapters. AutoAdapt figures out hidden domains on its own and trains these adapters independently, so they don’t interfere with each other. This approach matches the performance of training one big adapter for all domains, but is more flexible and cheaper to update.
Open → 2610.10349v1

Large language model agents avoid tool misuse with new inference method

Understanding and Mitigating Hallucination Escape in Tool-Using LLM Agents

Abstract: Large language models (LLMs) increasingly serve as autonomous agents that invoke external tools. However, this capability introduces tool hallucination, selecting incorrect tools or generating invalid calls. Existing mitigation methods report substantial improvements, yet we identify a previously overlooked failure mode that we term Hallucination Escape. These methods reduce hallucination on the tool configuration they are tuned on but increase it on other configurations, canceling out the gain. We further investigate this phenomenon and find that hallucination rises sharply when a model's intrinsic tool-use tendencies conflict with the current tool configuration, and that existing methods reinforce rather than suppress these tendencies, which in turn contributes to hallucination escape. Building on these findings, we propose EscapeGuard, a training-free inference-time method that combines conflict-aware gating with configuration-derived attention enhancement to mitigate tool hallucination while preventing hallucination escape. Across six benchmarks on various models, EscapeGuard reduces tool-selection hallucination by 9.0 pp and suppresses hallucination escape, lowering the cross-configuration mean by 23.7 pp and achieving an 89.1% net improvement in paired-query evaluation. We hope this work can encourage evaluation beyond a single tool configuration and pave the way for more reliable tool-using LLM agents.

Sat 3 OctComputation and LanguageArtificial Intelligence
The gist
Large language models (LLMs) sometimes pick the wrong tools or make errors when using external tools because they imagine things that aren't true, known as hallucination. The authors found that previous fixes only reduce this problem for specific tool setups but make it worse for others—a failure they call Hallucination Escape. They discovered this happens when the model's natural preferences clash with the tool setup, and past fixes actually strengthen these biases. To fix this, they created EscapeGuard, a method that works during inference without retraining, helping LLMs choose tools correctly across different setups and greatly reducing hallucination errors.
Open → 2610.04409v1

Personal AI devices balance speed cost and privacy in agent tasks

AgBench: Agentic AI Benchmarks for Personal AI Devices

Abstract: Agentic AI systems increasingly rely on cloud-hosted large language models for planning, tool use, and iterative execution, raising concerns about API cost and data exposure. Advances in personal AI devices enable agents to execute locally, but limited resources on device may affect task success and performance. Existing benchmarks are inadequate for systematically characterizing these trade-offs across devices, workloads, and deployment architectures. We present AgBench, a benchmark suite and open artifacts for reproducible evaluation of agentic AI on personal devices. Using AgBench, we evaluate local, hybrid, and cloud execution across agentic workloads, examining task success, latency, cloud API cost, and data exposure. Our results, drawn from over 162.07 million data points, show that personal AI devices can complete many agent tasks locally, but local-only execution generally has lower task success and longer completion times than cloud-only execution, especially as concurrency increases. Local-only execution eliminates cloud model API costs and sensitive-information exposure to cloud agents. Hybrid execution can improve task success, but its cloud cost and data exposure depend on how agents divide work and share information. No single architecture performs best across task success, goodput, cloud cost, and data exposure; deployment choices should reflect the intended workload and device capabilities. AgBench is available at https://anonymous.4open.science/r/AgBench-2777.

Tue 29 SeptArtificial IntelligencePerformance
The gist
Agentic AI systems often use big language models hosted in the cloud, which can cost money and share private data. The authors created AgBench, a test suite to measure how personal AI devices perform agent tasks locally, in the cloud, or a mix of both. They found local-only AI is slower and less successful but avoids cloud costs and data exposure. Using both local and cloud resources can help but depends on how work is split. No single method is best, so choices should fit the device and task.
Open → 2609.38652v1