Learning Evidence Highlighting for Frozen LLMs
| Authors | Shaoang Li et al. |
| Year | 2026 |
| HF Upvotes | 0 |
| arXiv | 2604.22565 |
| Download | |
| HF Page | View on Hugging Face |
Abstract
Large Language Models (LLMs) can reason well, yet often miss decisive evidence when it is buried in long, noisy contexts. We introduce HiLight, an Evidence Emphasis framework that decouples evidence selection from reasoning for frozen LLM solvers. HiLight avoids compressing or rewriting the input, which can discard or distort evidence, by training a lightweight Emphasis Actor to insert minimal highlight tags around pivotal spans in the unaltered context. A frozen Solver then performs downstream reasoning on the emphasized input. We cast highlighting as a weakly supervised decision-making problem and optimize the Actor with reinforcement learning using only the Solver's task reward, requiring no evidence labels and no access to or modification of the Solver. Across sequential recommendation and long-context question answering, HiLight consistently improves performance over strong prompt-based and automated prompt-optimization baselines. The learned emphasis policy transfers zero-shot to both smaller and larger unseen Solver families, including an API-based Solver, suggesting that the Actor captures genuine, reusable evidence structure rather than overfitting to a single backbone.
Engineering Breakdown
Plain English
This paper presents HiLight, a framework that helps frozen Large Language Models (LLMs) reason better by highlighting important evidence in long, noisy contexts. Instead of compressing or rewriting the input text—which can lose critical information—HiLight trains a lightweight neural module to insert minimal HTML-like emphasis tags around key passages in the original context. The frozen LLM then performs its reasoning task on the highlighted input. The approach is trained end-to-end using only the task reward signal from reinforcement learning, requiring no manual evidence annotations and no modification to the underlying LLM.
Core Technical Contribution
The core novelty is decoupling evidence selection from reasoning in a way that preserves the original input exactly. Most prior work either uses extractive summarization (which removes context) or rewriting (which can distort meaning), but HiLight adds only lightweight semantic markup around critical spans. The key insight is framing evidence highlighting as a weakly supervised reinforcement learning problem where a small Emphasis Actor learns which spans to highlight by optimizing the downstream task reward, with no ground-truth evidence labels required. This is fundamentally different from traditional information retrieval or extractive QA approaches because it operates within the reasoning pipeline itself and requires zero access to or modification of the frozen solver.
How It Works
The system consists of two components: a lightweight Emphasis Actor and a frozen Solver LLM. The Actor receives the raw input context and learns to insert special emphasis tags (e.g., [HIGHLIGHT] pivotal span [/HIGHLIGHT]) around critical evidence segments. The modified context flows to the frozen Solver, which performs the downstream task (e.g., answering a question or making a recommendation) on the emphasized input. The Actor is optimized via reinforcement learning where the reward signal comes directly from the Solver's task performance—if highlighting helps the Solver succeed, the Actor learns to highlight those spans; if it hurts, the Actor learns to avoid them. This creates a feedback loop without ever needing human-annotated evidence labels. The Actor is kept small enough to be efficient, while the Solver remains completely frozen and unmodified.
Production Impact
For production systems using frozen LLMs (which is common when you can't fine-tune or modify vendor models), this approach directly improves reasoning quality on evidence-heavy tasks like question-answering, recommendation, and knowledge-intensive retrieval without requiring retraining or access to the LLM weights. You would integrate HiLight as a lightweight preprocessing layer: feed raw context through the trained Actor, get highlighted output, pass it to your frozen LLM solver. The computational overhead is minimal since the Actor is small and inference is a single forward pass per request. The main trade-off is that you need a small amount of task-specific data to train the Actor—though the paper claims this is weakly supervised, so exact evidence annotations aren't needed, just final task rewards. Integration is clean: it works as a drop-in wrapper that requires no modification to downstream systems or LLM APIs.
Limitations and When Not to Use This
The paper assumes that highlight tags are actually useful to the frozen LLM, which may not always be true—some models might ignore or be confused by inserted markup. The approach requires reward signals from the task itself, which means it only works for tasks where you can measure success; tasks with sparse or delayed rewards will be harder to optimize. The method hasn't been evaluated on truly massive contexts (the paper abstract cuts off, but likely focuses on moderate-length documents), so scalability to retrieval-augmented generation with 10k+ token contexts is unclear. Additionally, the Actor training requires sufficient task-specific data with clear success signals; it won't work well in zero-shot or one-shot scenarios where you have no task examples. The paper also doesn't address whether the highlighted spans are interpretable to humans or whether the Actor might learn spurious correlations that don't generalize to new domains.
Research Context
This work builds on the growing research area of prompt engineering and context management for LLMs, which has explored techniques like in-context learning, retrieval-augmented generation, and chain-of-thought prompting. It sits at the intersection of interpretability research (making LLM reasoning more transparent via evidence highlighting) and RL-based adaptation of frozen models, which has become popular as commercial LLMs proliferate. The paper contributes to a broader trend of developing lightweight, adapter-based methods that work with frozen models—similar in spirit to LoRA and prompt tuning but applied to the input space rather than parameter space. This opens a research direction around how to optimally format or structure context for reasoning, and whether other semantic markup techniques could complement or replace highlighting.
:::tip Subscribe Get weekly breakdowns of papers like this in AI Letters - the newsletter for engineers building production AI systems. :::