Papers
Topics
Authors
Recent
Search
2000 character limit reached

AdaSR: Adaptive Streaming Reasoning with Hierarchical Relative Policy Optimization

Published 12 Jun 2026 in cs.CL | (2606.14694v1)

Abstract: Large reasoning models typically follow a read-then-think paradigm: they observe the complete input, reason over a static context, and then produce the answer. Yet many real-world scenarios are inherently dynamic, such as audio and video stream, where information arrives as a continuous stream and models must reason, update, and respond under partial observations. Recent streaming reasoning methods allow models to think while reading, but they largely rely on supervised imitation of pre-constructed trajectories, which limits their flexibility. In this paper, we propose AdaSR, an adaptive streaming reasoning framework that enables models to reason during input streaming and perform final deliberation once the stream is complete, learning when to think, and how much computation to allocate across different stages. To optimize this hierarchical reasoning process, we introduce Hierarchical Relative Policy Optimization (HRPO), which decomposes policy optimization into streaming reasoning and deep reasoning phases, providing more fine-grained advantage assignment instead of uniformly distributing a single sequence-level advantage over all tokens. HRPO integrates format, accuracy, and adaptive thinking rewards to enforce valid reasoning protocols, preserve final task performance, and encourage latency-aware computation allocation. Experiments show that AdaSR achieves a better balance among reasoning accuracy, computational efficiency, and streaming latency compared with supervised fine-tuning baseline. We release our code at https://github.com/EIT-NLP/StreamingLLM/tree/main/AdaSR.

Summary

  • The paper introduces AdaSR, which decouples streaming from deep reasoning to enable online, incremental inference under partial observations.
  • It pioneers Hierarchical Relative Policy Optimization (HRPO) to decompose credit assignment across streaming, deep, and global phases for enhanced decision-making.
  • Experimental results demonstrate substantial accuracy gains and reduced latency across benchmarks like GSM-Symbolic and MetaMathQA.

Adaptive Streaming Reasoning with Hierarchical Relative Policy Optimization: A Technical Analysis

Introduction and Motivation

The traditional chain-of-thought (CoT) paradigm in LLM reasoning assumes full input visibility prior to deliberation. This read-then-think protocol incurs suboptimal latency in domains where inputs arrive as streams, such as speech or real-time sensory data. Streaming reasoning seeks to interleave reasoning with input perceptionโ€”permitting online, incremental inference under partial observations. Prior approaches to streaming CoT have predominantly employed supervised imitation of expert-constructed trajectories, restricting adaptability and generality.

"AdaSR: Adaptive Streaming Reasoning with Hierarchical Relative Policy Optimization" (2606.14694) introduces a reinforcement learning (RL)-based framework to autonomously learn computation allocation policies in streaming contexts. By formulating an explicit separation between streaming and deep (post-stream) reasoning, AdaSR enables LLMs to dynamically decide when to think, when to skip, and how to balance computation for minimal latency and maximal task performance. At its core, AdaSR develops Hierarchical Relative Policy Optimization (HRPO), which decomposes trajectory-level credit assignment into phase-specific (streaming, deep, and global) advantagesโ€”a theoretically motivated refinement of the standard Group Relative Policy Optimization (GRPO) technique. Figure 1

Figure 1: AdaSR enables online reasoning over streaming inputs, with HRPO providing fine-grained temporal credit assignment aligning with the underlying hierarchical structure of streamed reasoning.

AdaSR Framework and Methodological Innovations

AdaSR couples a hierarchical RL objective with a streaming rollout engine, establishing a foundation for phase-structured credit assignment within reasoning trajectories.

Streaming Reasoning Paradigm

AdaSR's reasoning protocol is instantiated as follows:

  • For each revealed input segment, the model emits a streaming "thought" under current partial context, or may opt to skip.
  • After the input stream completes, a final deep deliberation integrates all prior context and thoughts, generating the ultimate answer.

Contrastingly, in read-then-think paradigms, reasoning and output are strictly deferred until full context arrival, resulting in increased response time. Figure 2

Figure 2: Streaming thinking enables concurrent reasoning and input perception, unlike read-then-think which accumulates input before any computation, causing delays.

Hierarchical Relative Policy Optimization (HRPO)

GRPO assigns a single normalized advantage to all tokens in a rollout. This sequence-level allocation fails for streaming settings: reward signals cannot distinguish between the utility of tokens generated under incomplete versus complete observations, creating a cross-phase credit paradox.

HRPO addresses this by decomposing the advantage into three temporally aligned levels:

  1. Streaming-local advantage: Assigned to tokens generated in the streaming phase, capturing the value of reasoning under partial context.
  2. Deep-local advantage: Assigned to tokens generated during the final deliberation phase, crediting synthesis over complete context.
  3. Trajectory-global advantage: Assigned across the full rollout, reflecting end-to-end task outcome.

HRPO's phase-structured surrogate objective supports both phase-specific and global policy updates. The mixing coefficient ฮป\lambda controls the balance between local and global signals, reducing to GRPO when set to zero. Figure 3

Figure 3: AdaSR training pipeline: streaming rollouts are constructed with position encoding and segmental caching, enabling consistent advantage computation for streaming-aware RL updates.

Reward Decomposition

AdaSR's reward function incorporates three tightly coupled components:

  • Format reward: Enforces syntactic correctness for intermediate and final outputs, ensuring parseability for phase assignments.
  • Accuracy reward: Anchors the global objective with the final answer correctness signal.
  • Adaptive thinking reward: Implements a length-based shaping penalty and latency discounts, incentivizing concise yet sufficient computation in both streaming and deep phases. Latency-aware discounting further prioritizes reasoning performed during the input stream, as this computation overlaps with real-time data arrival.

Experimental Results and Empirical Claims

AdaSR is evaluated on mathematical (GSM-Symbolic, MetaMathQA, GSM-Infinite), biomedical (PubMedQA), and logic (LogicNLI) datasets using the Qwen3 LLM series. Key benchmarks involve problems naturally segmentable to simulate streamed input.

AdaSR with HRPO achieves consistent and often substantial accuracy improvements versus both SFT-based StreamingThinker and GRPO baselines, with stronger gains on more challenging, longer-form benchmarks:

  • On GSM-symbolic P2 with Qwen3-1.7B, accuracy improves from 0.642 (SFT) and 0.758 (GRPO) to 0.788 (HRPO), while reducing deep-stage reasoning length by an order of magnitude compared to read-then-think.
  • For Qwen3-4B on MetaMathQA, accuracy rises from 0.860 (SFT) to 0.924 (HRPO) with a 13.4% reduction in total generated length relative to SFT.

AdaSR's streaming-deep computation division yields a more favorable accuracy/efficiency frontier. Compared to sequence-level RL, hierarchical advantage assignment enables AdaSR to suppress unnecessary token emissionsโ€”reducing redundancyโ€”without sacrificing global performance. Notably, token-level advantage assignment (overly fine granularity) degrades performance versus coarser, phase-aligned divisions, highlighting the necessity of granularity aligned with the semantic structure of streaming reasoning. Figure 4

Figure 4: HRPO delivers superior training dynamics with higher reward curves, better accuracy, and confident policy entropy declining steadily during training, as compared to GRPO and fine-grained variants.

AdaSR generalizes effectively in out-of-distribution (GSM-Infinite) and out-of-task (LogicNLI) scenarios, maintaining or improving accuracy while keeping total reasoning length compact.

Practical Implications and Theoretical Perspectives

The implications of AdaSR are multifaceted:

  • Practical serving: AdaSR's computation reallocation to streaming stages provides more than an 8ร—8\times reduction in post-input latency on real servers (e.g., vLLM), critical for interactive real-time applications.
  • Adaptive computation and RL-over-temporal structure: This framework formalizes RLHF/VRL objective decomposition across temporal/structural boundaries, offering a blueprint for adaptive, context-sensitive credit assignment in any phase-structured generative process.
  • Beyond text: While the present work focuses on segmented text streams with verifiable outputs, the architectural principles of AdaSRโ€”hierarchical advantage assignment, streaming rollouts, and adaptive reward shapingโ€”are extensible to continuous audio, video, and multimodal settings.
  • Open challenges: Extending AdaSR to continuous domains or temporally unaligned modalities will require reward designs that blend format, delayed accuracy, and richer phase-aware signals, as well as scalable rollout infrastructure for dynamic trajectory segmentation.

Comparative qualitative analysis further supports the capability of RL-trained AdaSR models to mitigate propagation of streaming-phase errors into the final answer, a limitation frequently observed in SFT-trained baselines. Figure 5

Figure 5: RL-trained AdaSR corrects intermediate computational steps during streaming, avoiding error propagation found in SFT-based reasoning.

Conclusion

AdaSR establishes that effective streaming reasoning in LLMs demands RL objectives tailored to the unique temporal structure of streamed input and output. Its HRPO method overcomes fundamental credit assignment failures of sequence-level RL in this context, yielding models that are more accurate, efficient, and responsive under streaming input dynamics. The theoretical and practical insights presented by AdaSR provide a foundation for future developments in adaptive LLM computationโ€”potentially spanning real-time multimodal reasoning and agentic interaction in dynamically evolving environments.

Paper to Video (Beta)

No one has generated a video about this paper yet.

Whiteboard

No one has generated a whiteboard explanation for this paper yet.

Explain it Like I'm 14

Explaining โ€œAdaSR: Adaptive Streaming Reasoning with Hierarchical Relative Policy Optimizationโ€

1) What is this paper about?

This paper is about teaching AI models how to โ€œthink while readingโ€ instead of waiting until theyโ€™ve read everything. In the real world, information often arrives bit by bitโ€”like hearing a sentence at a time, watching a video frame by frame, or getting sensor updates over time. The authors present a new method called AdaSR that helps AI decide when to think, when to wait, and how much โ€œbrainpowerโ€ to use at each moment as information streams in.

2) What questions are the researchers trying to answer?

The paper explores simple but important questions:

  • How can an AI reason as it reads, instead of waiting until the end?
  • How can it decide whether to think now, think later, or skip thinking for a moment?
  • How can it split its effort wisely between quick, ongoing thoughts and a final, deeper review at the end?
  • How can we reward the AI fairly so it gets credit for helpful early thoughts without encouraging wasteful overthinking?

3) How did they do it? (Methods in simple terms)

Think of a model like a student listening to a lecture that comes one sentence at a time. The student can:

  • Jot down a quick note after each sentence (streaming reasoning).
  • Do a final, careful summary after the lecture ends (deep reasoning).

The challenge is giving fair credit. If the final answer is correct, should the student get credit for every note they took? What if some notes were unnecessary? The paper introduces two main ideas:

  • Two stages of thinking
    • Streaming stage: quick thoughts as information arrives.
    • Deep stage: a final, more careful round of thinking after everything is known.
  • A smarter way to assign credit (HRPO)
    • In many previous methods, the model gets one big reward at the end, and that reward is spread evenly across all the words it wrote. Thatโ€™s like giving a sports team the same praise for every minute of the game, even if the winning play happened at the end.
    • The authors propose HRPO (Hierarchical Relative Policy Optimization), which gives credit separately to the two stages:
    • Credit for helpful quick thoughts (streaming).
    • Credit for the final, careful reasoning (deep).
    • Overall credit for the final answer being correct.
    • This helps the model learn which parts of its thinking were actually useful.

They also shape the rewards to guide behavior:

  • Format reward: Make sure the model follows the rules (e.g., clearly ends each short thought and the final reasoning).
  • Accuracy reward: Reward correct answers.
  • Adaptive thinking reward: Encourage using only as many words (tokens) as neededโ€”donโ€™t be too wordy, but donโ€™t be too brief either. It gently prefers doing more thinking during streaming (which can overlap with reading) and keeping the final stage short (which affects how long you wait for the final answer).

Finally, they built all this into an efficient system so it can run fast in practice using modern inference engines.

4) What did they find, and why does it matter?

Main takeaways:

  • Better accuracy with less waiting: The new method, AdaSR with HRPO, often gets more answers right than older approaches and reduces the time users have to wait for the final answer. It does this by moving some thinking into the streaming stage and keeping the final stage shorter.
  • Smarter use of effort: Compared to methods that imitate fixed examples, AdaSR learns to think more when it helps and skip when it doesnโ€™t. It doesnโ€™t just produce longer explanationsโ€”it produces more useful ones.
  • Works across tasks and sizes: They tested on math, science/medical question answering, and logic tasks using different model sizes. The improvements held up, including on datasets that were different from the training data.
  • Practical speedups: With a fast backend (vLLM), streaming reasoning cut visible latency (the time users wait) by over 8ร— compared to the traditional โ€œread-then-thinkโ€ setup.

Why it matters:

  • Many real-world systems (voice assistants, live translation, video analysis, robots, and sensors) donโ€™t get all the information at once. Teaching models to reason as they read can make them more responsive and efficient, which is better for user experience and real-time applications.

5) Whatโ€™s the impact and what could come next?

This work shows that โ€œthinking while readingโ€ isnโ€™t just a neat trickโ€”itโ€™s a different kind of problem that needs smarter training and fairer credit assignment. The approach can:

  • Make AI assistants feel snappier and more helpful in real-time situations.
  • Reduce unnecessary computation, which can save time and energy.
  • Lead to safer and more reliable behavior by encouraging the model to reason at the right times.

For future work, the authors note that they focused on text with clear right-or-wrong answers. Next steps include applying these ideas to streaming audio, video, and interactive tasks where rewards are more complex and the inputs are multi-modal.

Knowledge Gaps

Knowledge gaps, limitations, and open questions

Below is a concise, actionable list of what remains missing, uncertain, or unexplored in the paper.

  • Modalities and tasks: The framework is only validated on text streams with verifiable final answers; it does not address audio/video streams, multimodal inputs, or open-ended/subjective tasks where final correctness is not binary or easily computable.
  • External validity: Evaluation is limited to Qwen3-1.7B/4B on a small set of math/QA/logic datasets; it remains unclear how AdaSR/HRPO perform across diverse model families (e.g., Llama, Gemma, Mistral), larger scales, different languages, or domains like software debugging and real-time planning.
  • Streaming segmentation: Inputs are segmented into sentences; the sensitivity of results to segmentation policy (chunk size, punctuation errors, noisy ASR segmentation, variable input rates) and to non-sentential streaming (token- or phrase-level chunks) is not explored.
  • Latency realism: Latency is measured under simulated streaming (150 wpm) and token counts; effects of deployment factors (network jitter, variable input cadence, strict real-time deadlines, energy/GPU-time per token) are not quantified.
  • Reward design robustness: The adaptive thinking reward penalizes length with gates tied to correctness/format; risks of reward hacking, over-optimization to length proxies, and robustness to noisy labels or partial credit tasks are unstudied.
  • Generalization to non-verifiable objectives: The approach relies on accuracy rewards; how to extend HRPO to tasks without ground-truth answers (e.g., summarization, dialogue, creative writing) using preference models or human feedback remains open.
  • Phase boundary assumptions: The deep-reasoning phase always starts after the final input segment; learning to trigger deep reasoning earlier (or produce final answers mid-stream) and dynamically choosing phase boundaries is not investigated.
  • Hierarchical granularity: Only a two-stage hierarchy (streaming vs deep) is considered; whether finer or task-adaptive hierarchies (e.g., multi-stage streaming, sub-phases within deep reasoning) can improve credit assignment remains unknown.
  • Theoretical guarantees: HRPOโ€™s bias/variance properties, convergence behavior, and theoretical relation to standard policy gradient under hierarchical credit assignment are not analyzed beyond empirical results.
  • Hyperparameter sensitivity: The paper references appendix analyses but lacks systematic, main-text exploration of sensitivity to ฮป (localโ€“global mixing), ฮฒ (length reward weight), ฯ„ and ฮฑ (latency shaping), group size G, PPO clip ฮต, and KL ฮฒ; automated scheduling or meta-learning of these is not addressed.
  • Stability and sample efficiency: The impact of HRPO on training stability, variance, and sample efficiency versus GRPO (especially under sparse rewards or small G) is not quantified; ablations on group size and rollout count are missing.
  • Memory and compute overhead: The cost of storing and backpropagating through all streaming thoughts (Rโ‚โ€ฆR_T) is not reported; memory scaling with long streams and the effect on KV-cache reuse or GPU footprint under vLLM are not measured.
  • Streaming position encoding portability: The method relies on custom position IDs and attention masks; portability to different positional schemes (RoPE, ALiBi) and to other serving stacks beyond vLLM needs validation.
  • Baselines on adaptive compute: Comparisons omit alternative adaptive inference methods (e.g., early-exit classifiers, test-time compute allocation, dynamic halting, self-consistency pruning); it is unclear how AdaSR fares against these.
  • Failure analyses: When HRPO-sentence/token variants degrade accuracy or over-compress reasoning, qualitative analyses of failure modes are not provided; criteria for choosing granularity per task are not established.
  • Robustness to streaming noise: The system is not tested under noisy or adversarial streams (ASR errors, reordering, missing segments, contradictions); robustness of streaming decisions and final accuracy under such conditions is unknown.
  • Memory management of thoughts: The deep phase consumes all prior streaming thoughts; mechanisms to compress, prune, or retrieve only relevant thoughtsโ€”and the effect on accuracy and latencyโ€”are not explored.
  • Safety and user experience: If intermediate thoughts are surfaced or logged, implications for privacy, premature conclusions, or misleading partial outputs are not studied; strategies for safeguarding early reasoning are absent.
  • Budgeted inference: The framework optimizes token-length proxies but does not enforce hard latency/compute budgets or deadlines; extending HRPO to constrained optimization (e.g., knapsack-like budgets per query) remains open.
  • Multi-task reward blending: Advantage composition is per-level but not per-task; how to balance competing objectives (accuracy vs latency) across heterogeneous tasks or user personas is not resolved.
  • OOD breadth: OOD tests (GSM-Infinite, LogicNLI) are narrow; broader distribution shifts (long-context narrative QA, domain shift in biomedical/coding, multilingual streams) are not evaluated.
  • Token-level credit signals: Only format-related token-level credit is attempted; methods to derive token-aligned semantic credit (e.g., via temporal-difference critics, hindsight credit assignment) are not explored.
  • Integration with value functions: HRPO removes value models like GRPO; whether adding lightweight critics for phase-local baselines can reduce variance or improve credit assignment is an open direction.
  • Reward latency weighting: The latency-aware reward assumes uniform per-token cost; accounting for growing KV-cache, heterogeneous hardware, or batching effects could alter optimal compute allocation.
  • Incremental output tasks: Tasks requiring external, incremental outputs (e.g., simultaneous translation, streaming captioning) are not tested; how AdaSR handles emitting partial user-facing outputs (not just internal thoughts) is unclear.
  • Curriculum and exploration: No curriculum or exploration strategies tailored to streaming (e.g., curriculum over stream length or chunk variability) are studied; entropy schedules and their effect on adaptivity are underexplored.
  • Privacy and data retention: The framework accumulates streaming thoughts; policies for retention, truncation, or anonymization (especially with sensitive streams) are not discussed.

Practical Applications

Practical Applications of AdaSR (Adaptive Streaming Reasoning with HRPO)

AdaSR enables LLMs to โ€œthink while readingโ€ streaming inputs and to allocate computation between an intermediate (streaming) phase and a final (deep) phase using a stage-aware reinforcement learning algorithm (HRPO). Below are actionable, real-world applications derived from the paperโ€™s findings, methods, and innovations.

Immediate Applications

These can be built now with text or transcript streams, existing LLMs, and a vLLM-compatible serving stack.

  • Real-time customer support and contact-center agent assist
    • Sector: Software, customer service
    • What: As a customer speaks or messages arrive, the system reasons incrementally (e.g., infers intent, retrieves articles) and provides immediate suggestions; it performs a brief final deliberation to consolidate solutions at turn end.
    • Tools/products/workflows:
    • Integrate ASR โ†’ text stream โ†’ AdaSR backend (vLLM).
    • Use HRPO-trained policies to decide โ€œthink vs skip,โ€ keep deep-phase short to minimize on-call latency.
    • Add observability: metrics for streaming vs deep-phase token budgets, latency, and accuracy.
    • Assumptions/dependencies:
    • Reliable ASR for speech; robust segmentation into sentences/clauses.
    • Reward design for training may rely on verifiable resolution outcomes (ticket solved, QA accuracy) or proxy metrics.
  • Simultaneous speech translation and live interpretation assist
    • Sector: Language services, media
    • What: While listening to input, the model generates incremental translations and clarifications; deep-phase refines phrasing at segment boundaries.
    • Tools/products/workflows:
    • Pipeline: ASR โ†’ sentence/phrase segmentation โ†’ AdaSR translation model with latency-aware reward (adjust ฮฑ, ฯ„ to reflect latency targets).
    • Deploy on vLLM for low-latency streaming.
    • Assumptions/dependencies:
    • Currently text-stream in/out (audio handled by ASR front-end).
    • Data and reward signals for translation quality and latency.
  • Meeting copilots (live summaries, action items, follow-ups)
    • Sector: Productivity, enterprise SaaS
    • What: Generate incremental topic summaries and action-item candidates during the meeting; finalize a concise summary at meeting end.
    • Tools/products/workflows:
    • Real-time transcript feed โ†’ AdaSR notes/extracts โ†’ final synthesis.
    • HRPO rewards tuned to suppress redundant verbosity mid-call, preserve concise final output.
    • Assumptions/dependencies:
    • High-quality transcript; tasks with partial verifiability (e.g., correct extraction of names, dates).
  • IDE/code-assistant โ€œtype-aheadโ€ reasoning
    • Sector: Software engineering, developer tools
    • What: As developers type, the assistant reasons about possible errors/tests and suggests minimal fixes; performs a quick deep-phase check on save or test run.
    • Tools/products/workflows:
    • Streaming diffs from the editor โ†’ AdaSR code reasoner.
    • Token budget knobs to keep suggestions sub-100 ms; deep-phase constraints for tight edit loops.
    • Assumptions/dependencies:
    • Verifiable tasks (unit-test pass/fail, lint rules) for RL signals.
    • IDE integration and safety filters.
  • Live content moderation and trust & safety triage
    • Sector: Online platforms, community management
    • What: Streamed chat/comments are triaged with early warnings (e.g., probable policy violation); final deep-phase aggregates context for higher-confidence decisions or escalation.
    • Tools/products/workflows:
    • Moderation labels โ†’ HRPO training with format and length rewards to limit latency.
    • โ€œSkipโ€ when context is insufficient; only deep-think when a threshold is crossed.
    • Assumptions/dependencies:
    • High-quality labels; fairness and bias checks.
    • Human-in-the-loop for enforcement in ambiguous cases.
  • Streaming news and market intelligence alerts
    • Sector: Finance, enterprise risk
    • What: As newswire/filings stream, the model flags potential risk themes early; consolidates relevant details when more evidence accumulates.
    • Tools/products/workflows:
    • Topic/risk classifier with AdaSR; deep-phase only when a plausible risk pattern emerges.
    • Latency-aware reward to prioritize early-but-cautious alerts.
    • Assumptions/dependencies:
    • Proxy rewards (click-through, analyst confirmation) when ground truth is delayed.
    • Compliance guardrails and audit trails.
  • On-device/edge pre-processing with cloud refinement
    • Sector: IoT, mobile/edge AI
    • What: Lightweight streaming reasoning at the edge (filtering, early classification) with a small deep-phase offloaded to the cloud when needed.
    • Tools/products/workflows:
    • Two-tier deployment: streaming-phase on-device, deep-phase in cloud; token budgets enforced per tier.
    • vLLM or equivalent for cloud; compact local model for edge.
    • Assumptions/dependencies:
    • Stable connectivity for deep-phase offload; privacy/security constraints.
    • Task-specific rewards for edge objectives (e.g., bandwidth saved, false-alarm cost).
  • Live clinical scribe and telehealth assistant (non-diagnostic)
    • Sector: Healthcare (administrative support)
    • What: Draft notes, highlight problems/medications during the conversation; perform a final pass to structure SOAP notes at session end.
    • Tools/products/workflows:
    • Transcript โ†’ AdaSR โ†’ incremental notes + final structured export to EHR template.
    • Rewards prioritize structured formats and brevity mid-call.
    • Assumptions/dependencies:
    • Not for diagnosis; requires strict PHI handling, auditability, clinician oversight.
    • Verifiable formatting/coverage metrics for RL shaping.
  • Education and tutoring assistants
    • Sector: Education/EdTech
    • What: Provide step-wise hints as a learner works through problems; finalize solution explanation after full problem is read.
    • Tools/products/workflows:
    • Use datasets with verifiable answers (e.g., GSM-like) for training.
    • Limit deep-phase token use to maintain interactivity.
    • Assumptions/dependencies:
    • Careful reward design to avoid over-revealing answers; pedagogy-aligned hinting.
  • Incident/operations triage from streaming logs
    • Sector: DevOps, SRE, IT operations
    • What: Early detection of anomalies from log streams with incremental reasoning; final consolidation when sufficient evidence arrives.
    • Tools/products/workflows:
    • Log ingestion โ†’ AdaSR anomaly reasoner; skip routine messages, think on anomalies.
    • Deep-phase generates incident summaries/playbooks.
    • Assumptions/dependencies:
    • Labels or proxy rewards (MTTR, false-positive cost).
  • Developer/infra productization
    • Sector: MLOps/LLMops
    • What: Ship an โ€œAdaptive Streaming Reasoner SDKโ€ with:
    • vLLM-compatible streaming position encoding and masks.
    • HRPO training scripts and reward templates (format, accuracy, length).
    • Budget controller to set max streaming/deep tokens per request.
    • Assumptions/dependencies:
    • Base model quality sufficient for target tasks; GPU resources for RL.

Long-Term Applications

These require multimodal support, richer reward signals, regulatory approvals, or further scaling.

  • End-to-end audio/video streaming reasoning
    • Sector: Media, security, sports, retail
    • What: Directly reason over continuous audio/video (e.g., highlight plays, detect safety events) with incremental updates and final summaries.
    • Tools/products/workflows:
    • Modality-specific rollout engines; HRPO extensions with multimodal rewards.
    • Assumptions/dependencies:
    • Robust multimodal encoders; ground-truth labels for streaming events; higher compute.
  • Safety-critical robotics and autonomous systems
    • Sector: Robotics, automotive, industrial automation
    • What: Allocate compute to early hazard assessment, then deep-phase consolidation for path planningโ€”balancing speed and accuracy.
    • Tools/products/workflows:
    • Hybrid stack: classical perception + AdaSR-high-level reasoning.
    • Fail-safes and verification for temporal credit assignment.
    • Assumptions/dependencies:
    • Certification, redundancy, formal guarantees; rigorous offline/online evaluation.
  • Continuous patient monitoring and early-warning systems
    • Sector: Healthcare (clinical decision support)
    • What: Streaming vitals and notes feed incremental risk assessment; deep-phase synthesizes multi-sensor trends for alerts.
    • Tools/products/workflows:
    • HRPO rewards reflecting clinical utility (sensitivity/specificity vs alarm fatigue).
    • Assumptions/dependencies:
    • Regulatory approval; clinical trials; explainability; data privacy.
  • Multi-agent, interactive systems with partial observability
    • Sector: Gaming, operations research, logistics
    • What: Agents that adapt compute to evolving state (streaming reasoning while observing, deep-phase at critical decision points).
    • Tools/products/workflows:
    • Integration with environment simulators; reward designs for long-horizon outcomes.
    • Assumptions/dependencies:
    • Stable interfaces for streaming observations; domain-specific safety/ethics.
  • Networked edgeโ€“cloud compute orchestration
    • Sector: Cloud/edge infrastructure
    • What: System-level schedulers that dynamically allocate streaming vs deep-phase compute across nodes to meet latency SLAs.
    • Tools/products/workflows:
    • Serving layer integrates HRPO signals with cluster QoS policies.
    • Assumptions/dependencies:
    • Multi-tenant fairness; cost-aware scheduling; robust monitoring.
  • Finance-grade surveillance and compliance copilot
    • Sector: Finance, regtech
    • What: Real-time surveillance reasoner that incrementally flags potential issues; deep-phase builds regulator-ready rationales.
    • Tools/products/workflows:
    • Audit trails capturing streaming and deep tokens; controls on token budgets by risk tier.
    • Assumptions/dependencies:
    • Human review; model risk management; explainability requirements.
  • Policy and standards for streaming LLMs
    • Sector: Public policy, standards bodies
    • What: Benchmarks and compliance guidelines that account for latency-aware reasoning and temporal credit assignment.
    • Tools/products/workflows:
    • Open datasets and evaluation suites that report accuracy, streaming latency, deep-phase latency, and token budgets.
    • Assumptions/dependencies:
    • Community consensus on metrics; reproducible serving conditions.
  • Energy-aware and sustainability-focused serving
    • Sector: Energy/Green AI
    • What: Dynamically reduce deep-phase compute to meet energy budgets during peak load; shift work into streaming when feasible.
    • Tools/products/workflows:
    • Energy-aware reward shaping; cluster controllers that tune token budgets by grid signals.
    • Assumptions/dependencies:
    • Accurate energy telemetry; acceptance of adaptive quality under constraints.
  • Domain-adaptive RL pipelines for non-verifiable tasks
    • Sector: Cross-industry
    • What: Extend HRPO with preference learning or implicit feedback where exact answers are unavailable (e.g., summarization, creative tasks).
    • Tools/products/workflows:
    • Reward models from user ratings; bandit or preference-optimized HRPO variants.
    • Assumptions/dependencies:
    • Data collection pipelines; bias and safety mitigation.
  • Hardware/accelerator co-design for streaming reasoning
    • Sector: Semiconductors, systems
    • What: Specialized kernels/memory layouts for streaming positional encodings and masks; token-level budget enforcement in hardware.
    • Tools/products/workflows:
    • Compiler/runtime support for dynamic masks; preemption for deep-phase bursts.
    • Assumptions/dependencies:
    • Vendor adoption; cost/benefit vs general-purpose hardware.

Cross-Cutting Assumptions and Dependencies

  • Input form: Immediate deployments assume text streams (or speech with ASR). Multimodal audio/video needs new rollout engines and rewards.
  • Rewards and ground truth: Accuracy reward works best when answers are verifiable; otherwise, use proxy signals (preferences, click-through, human ratings).
  • Serving stack: vLLM (or equivalent) must support streaming position encodings and attention masks; throughput and latency gains depend on overlapping compute with input arrival.
  • Model quality and safety: Base model competence, domain adaptation, and robust safety filters (especially for healthcare/finance) are essential.
  • Compute and cost: HRPO training is more involved than SFT; monitoring and token-budget enforcement are needed to control inference cost.
  • Governance: For regulated settings, maintain logs of streaming thoughts and final deliberation, enable human oversight, and ensure explainability.

These applications leverage AdaSRโ€™s core strengths: deciding when to think vs skip under partial observations, allocating compute to meet latency/accuracy targets, and deploying efficiently via a vLLM-compatible streaming pipeline.

Glossary

  • Accuracy reward: A terminal task signal that grants positive feedback when the final answer is correct. "The accuracy reward provides the terminal task signal:"
  • AdaSR (Adaptive Streaming Reasoning): A framework that enables models to decide when and how much to think during streaming inputs and during final deliberation. "we propose AdaSR, an adaptive streaming reasoning framework that enables models to reason during input streaming"
  • Adaptive thinking reward: A reward that shapes how much computation the model allocates by penalizing excessive token lengths while allowing necessary reasoning. "The adaptive thinking reward uses token length as a proxy for computation allocation."
  • Chain-of-thought (CoT) reasoning: A method where models produce intermediate reasoning steps before giving the final answer. "often through chain-of-thought (CoT) reasoning"
  • Cross-phase credit paradox: A misattribution issue where success in one phase wrongly boosts or suppresses contributions in another. "GRPO's uniform advantage assignment leads to a cross-phase credit paradox: deep-phase success can falsely amplify redundant streaming thoughts, while deep-phase inefficiency can unfairly suppress useful ones."
  • Deep phase: The post-stream stage where the full context is integrated into a final, deliberative reasoning response. "The second factor is the deep phase, integrating Cโ‰คTC_{\leq T} and Rโ‰คTR_{\leq T} into the final response RR."
  • Format reward: A structural constraint ensuring outputs are parseable and adhere to required tokens (e.g., <EOT>, <EOR>). "The format reward makes rollouts parseable for HRPO."
  • GDPO: A reinforcement learning variant noted for multi-reward normalization strategy used in advantage composition. "Following the multi-reward normalization observation in GDPO~\citep{liu2026gdpo}"
  • Group Relative Policy Optimization (GRPO): An RL objective that computes sequence-level relative advantages within a sampled group, avoiding value models. "A natural starting point is Group Relative Policy Optimization (GRPO)~\citep{shao2024deepseekmath}"
  • Group-relative normalization: Normalizing rewards relative to other samples within the same group to compute advantages. "HRPO keeps the group-relative normalization of GRPO"
  • Hierarchical Advantage Assignment: A credit assignment approach that splits advantages across streaming-local, deep-local, and global levels. "Hierarchical Advantage Assignment"
  • Hierarchical Relative Policy Optimization (HRPO): An RL method that decomposes policy optimization by assigning stage-aware advantages to streaming and deep phases. "we introduce Hierarchical Relative Policy Optimization (HRPO)"
  • Importance ratio: The token-wise probability ratio between current and old policies used for off-policy correction and clipping. "the token-wise importance ratio is paired with a sequence-level advantage"
  • Kullbackโ€“Leibler (KL) regularization: A penalty encouraging the updated policy to remain close to a reference policy. "with ฮฒ\beta controlling the KL regularization strength."
  • Latency-aware computation allocation: Rewarded behavior that balances where and how much reasoning occurs to reduce end-to-end delay. "and encourage latency-aware computation allocation."
  • Pareto improvement: Simultaneous gains (e.g., higher accuracy and shorter outputs) without sacrificing other metrics. "This suggests that stronger base models can turn adaptive streaming reasoning into a Pareto improvement."
  • Proximal Policy Optimization (PPO): A trust-region RL algorithm using clipped objective functions for stable policy updates. "In PPO~\citep{schulman2017proximal}, old-policy rollouts are reweighted token by token and clipped to stabilize updates"
  • Read-then-think pattern: A baseline paradigm where models only start reasoning after seeing the entire input. "This paradigm follows a read then think pattern"
  • Sequence-level advantage: A single advantage value applied uniformly across all tokens of a generated sequence. "uniformly distributing a single sequence-level advantage over all tokens."
  • Streaming attention masks: Attention constraints that prevent the model from accessing future input during streaming generation. "Streaming attention masks prevent attending to future input during the streaming phase."
  • Streaming position encoding: A positional scheme where input and reasoning tokens maintain separate positional indices during streaming. "Position IDs implement streaming position encoding---input tokens and reasoning tokens maintain independent positional indices"
  • Streaming rollout: The inference/training procedure that decodes intermediate thoughts as input arrives and final thoughts after the stream ends. "we implement streaming rollout by extending the vLLM inference engine~\citep{kwon2023efficient}"
  • Streaming thinking: A paradigm where the model reasons incrementally as the input stream unfolds. "streaming thinking ... lets reasoning unfold with the input stream"
  • Success-conditioned trajectory-level efficiency reward: A global reward that promotes sufficient but not excessive reasoning after verifying format and correctness. "We therefore introduce a success-conditioned trajectory-level efficiency reward:"
  • Temporal credit assignment: The challenge of attributing rewards to decisions made at different times (streaming vs. deep phase). "The central difficulty in streaming reasoning is temporal credit assignment"
  • Test-time compute allocation: Deciding how much computation to expend during inference, depending on the inputโ€™s difficulty and stage. "echoing broader efforts on adaptive computation and test-time compute allocation"
  • Trust-region behavior: The stability property achieved by clipping updates so the new policy doesnโ€™t deviate too far from the old one. "inherits PPO's trust-region behavior through the clipping threshold ฮต\varepsilon"
  • vLLM inference engine: A high-throughput serving backend adapted here for streaming training and decoding. "we implement streaming rollout by extending the vLLM inference engine~\citep{kwon2023efficient}"

Open Problems

We haven't generated a list of open problems mentioned in this paper yet.

Collections

Sign up for free to add this paper to one or more collections.