Hybrid Reasoning Agents

Abstract: How can we build an agent that thinks beyond human language, yet still acts through it in the external environment? Modern LLM agents still reason and interact through text, while latent reasoning offers an efficient internal medium but lacks native tool access and reasoning transparency. We bridge these two directions with Hybrid Reasoning Agents (HybridAgents), which dynamically navigate between latent reasoning and text-based interaction throughout a unified generation process. Architecturally, a lightweight HybridLink enables seamless transitions between text and latent modes, while the agent's continuous working memory preserves lossless hybrid context across multiple turns. These designs preserve tool-integrated agentic capabilities while making latent thoughts directly inspectable. Building on this architecture, we further develop dedicated post-training algorithms for hybrid reasoning: HybridSFT stabilizes tool-integrated hybrid generation by teaching the backbone to coordinate with HybridLink, then HybridRL scales reasoning by learning when to think in latent space and when to act through text. We evaluate HybridAgent at 3 model scales across 11 benchmarks covering mathematics, science, medicine, search, and agentic reasoning. Compared with frontier LLM Agents and agentic frameworks spanning both text-based and latent methods, HybridAgent consistently improves performance by 10.4%, while delivering 35.5%-54.7% token reduction, 1.8x-2.6x faster inference, and 2.7x-3.7x cost savings. Code and data are available at https://github.com/togethercomputer/HybridAgent.

• The paper introduces HybridAgent, a single autoregressive agent combining latent and text-based reasoning modes to improve efficiency and performance in tasks requiring both internal computation and external interaction.
• Evaluations across 11 benchmarks showed a 10.4% performance improvement, 35.5%–54.7% reduction in token usage, and 1.8x–2.6x inference speedup compared to text-based agents, with a substantial cost reduction of 2.7x–3.7x.
• The system uses HybridLink for mode transitions, multipurpose hybrid memory, and self-conditioned training methods, enhancing computational efficiency while maintaining interpretable reasoning and tool use, but contains some limitations requiring further research for integration into large-scale deployment.

HybridAgent addresses a structural tension in contemporary language agents: text is necessary for tool invocation, environmental interaction, and external inspection, but token-level reasoning is computationally expensive and forces every intermediate state through a discrete linguistic bottleneck. Latent-reasoning methods reduce this overhead by recurrently feeding hidden representations back into the model, but generally lack native tool interfaces and interpretable intermediate traces. “Hybrid Reasoning Agents” (2610.18861) proposes a single autoregressive agent that dynamically alternates between latent and text modes, using latent computation for internal reasoning and text for tool use, monitoring, and externally relevant decisions.

Problem formulation and central contribution

The paper’s central claim is that latent reasoning and agentic interaction need not be implemented as separate systems or separate inference passes. A HybridAgent can generate a trajectory containing text spans, continuous latent states, tool calls, tool observations, and subsequent text, while preserving a single causal computation graph. The proposed design therefore separates two functions that conventional agents conflate:

• Internal computation is conducted in continuous latent space without decoding every intermediate state into text.
• External interaction remains text-based so that tools, environments, and monitoring systems can consume discrete representations.

This division is particularly consequential for long-horizon tasks. A text-centric agent pays the cost of decoding and processing every reasoning step, even when the step has no immediate communicative or tool-use function. HybridAgent instead allows reasoning spans to remain latent and exposes only selected decision-critical states.

The system is built around three components: HybridLink, continuous KV working memory, and post-training procedures specifically adapted to hybrid trajectories. Figure 1 summarizes the architecture and the direction of information flow between latent computation and text-based action.

Figure 1: HybridAgent combines latent internal reasoning, text generation, tool interaction, and persistent hybrid working memory within one generation process.

The paper reports evaluations across 11 benchmarks and three Qwen3-Base model scales: 4B, 8B, and 14B parameters. Its headline results are a mean performance improvement of 10.4% relative to the principal matched baselines, a 35.5%–54.7% reduction in token usage, a 1.8x–2.6x inference speedup, and estimated cost reductions of 2.7x–3.7x. These claims are substantial, although the cost estimates depend on a particular accounting convention and exclude prompt-prefill, context-dependent attention, and external tool execution.

HybridLink and dynamic mode transitions

A standard latent-reasoning mechanism feeds the final hidden state directly into the next input position. The authors argue that this creates a distributional mismatch when latent states are interleaved with token embeddings: the hidden-state representation is not necessarily aligned with the pretrained input embedding space. HybridAgent therefore introduces HybridLink, a residual two-layer adapter:

$\mathcal{R}(h_t)=h_t+W_2\sigma(W_1h_t).$

The residual path is intended to preserve the semantic content of the hidden state while the learned branch aligns its distribution with the input embedding space. The module contains approximately $2d_h^2$ parameters, which the paper characterizes as lightweight relative to the backbone; for a 4B model, the adapter contains approximately 10M parameters.

Text mode operates as in a conventional autoregressive LLM. The model samples tokens until it emits an entry anchor, <latent>. In latent mode, the LM head and token embedding lookup are bypassed: each hidden state is transformed through HybridLink and fed back as the next latent input. The latent span terminates when the HybridLink output is closest, under cosine similarity, to the embedding of the exit anchor </latent>. The model then resumes text generation.

This arrangement makes mode selection endogenous. The length and frequency of latent spans are not imposed by a fixed schedule; the model learns when to enter, continue, and exit latent reasoning. The exit mechanism is asymmetric with respect to entry. Entry is a discrete text-generation decision, whereas exit is inferred from a continuous latent state through nearest-token alignment.

A notable and potentially controversial claim is that the latent states are not merely useful but also directly inspectable. The authors map each latent vector to its nearest token embedding and interpret the resulting sequence as pseudo-text. Their evaluation measures both nearest-token alignment and context specificity relative to the originating question. This is a geometric proxy for interpretability rather than a direct semantic guarantee: high cosine similarity to vocabulary embeddings does not by itself establish faithful causal correspondence between the readout and the computation that produced the answer.

Figure 2: Nearest-token readouts are used to assess the readability and question-specificity of latent reasoning spans.

The paper nevertheless provides causal evidence that the latent states are functionally used. On MATH500, replacing latent vectors with random-token embeddings reduces accuracy to 41.2% at 8B and 44.6% at 14B, compared with 84.6% and 88.2% for the unmodified HybridAgent. Replacing latent spans with states from another problem yields 44.8% and 48.6%, respectively. By contrast, nearest-token replacement, which preserves approximate embedding geometry while discarding some continuous information, produces 82.6% and 87.2%. The stronger degradation from cross-problem replacement than from Gaussian perturbation supports the narrower claim that problem-specific latent content matters, although these interventions do not establish that nearest-token pseudo-text is a complete or faithful explanation of the latent computation.

Multi-turn hybrid working memory

Interleaving latent vectors and text creates a context-management problem. A conventional agent can append prior turns as text and re-encode them, but latent states cannot be reconstructed from ordinary tokenization without information loss. HybridAgent resolves this by retaining the Transformer’s key-value entries as continuous working memory.

The memory stores KV entries generated from initial text, latent inputs, tool calls, and tool observations. Subsequent turns directly append new entries to the existing memory rather than reconstructing the entire hybrid trajectory in token space. Tool observations are inserted into this ongoing sequence, allowing the agent to resume latent reasoning after an external interaction.

Figure 3: Persistent KV working memory retains text, latent states, and tool observations across multiple turns without converting latent context back into text.

The paper proves a lossless-continuation theorem under explicit assumptions: the model parameters, HybridLink, positional encoding, causal masks, inference settings, and stored KV entries remain consistent. Under these conditions, a cached forward pass produces the same hidden states as recomputing the full hybrid prefix. The result is technically important but narrower than a general claim about memory quality. It establishes computational equivalence for exact KV preservation, not robustness to cache compression, eviction, quantization, distributed serving errors, or changes in the tool environment.

This design also changes the unit of context management. Whereas standard agent frameworks treat context as a sequence of serializable messages, HybridAgent treats context as a persistent computational state. That choice supports lossless hybrid continuation but increases infrastructure requirements: the serving engine must preserve per-layer, per-head KV state across asynchronous tool calls and must track mode transitions and positions independently for each batched trajectory.

HybridSFT and the train–inference mismatch

The authors identify a specific failure mode in naïve hybrid fine-tuning. During teacher-forced activation, the backbone consumes ground-truth token embeddings at latent positions while HybridLink is trained to predict embeddings aligned with those targets. At inference, however, the backbone consumes HybridLink’s own continuous predictions. Errors in one latent step therefore become inputs to subsequent steps and can accumulate over a long latent span.

Figure 4: Self-conditioned HybridSFT exposes the backbone to HybridLink-generated latent inputs during training, reducing the mismatch between teacher-forced activation and free-running inference.

HybridSFT uses three stages. First, standard text SFT teaches the backbone to emit the latent-entry and latent-exit anchors. Second, HybridLink is trained to align its outputs with target embeddings using cosine and mean-squared-error losses. Third, self-conditioned training performs two passes: a teacher-forced pass generates HybridLink predictions, and a second pass replaces ground-truth latent embeddings with those predictions while jointly training the backbone and HybridLink.

The ablation results indicate that the third stage is essential. For Qwen3-14B-Base, MATH500 accuracy increases from 47.0 for the base model to 62.4 after format activation, 73.8 after HybridLink activation, and 84.2 after self-conditioned HybridSFT. On AIME25, the corresponding progression is 4.9, 20.6, 23.8, and 32.5; on AIME26, it is 3.0, 19.8, 22.5, and 31.7. Self-conditioning improves performance over HybridLink activation by an average of 30.5% according to the paper’s relative comparison.

These results support the authors’ diagnosis that latent recurrence is unusually sensitive to exposure bias because the model’s own continuous outputs occupy a potentially untrained region of input space. They also establish an important qualification: simply attaching an adapter to a pretrained LLM is insufficient. Stable hybrid reasoning requires joint adaptation to the distribution of self-generated latent inputs.

Figure 5: Successive activation and self-conditioning stages improve both downstream reasoning performance and the measured transparency of latent spans.

The hybrid data are generated automatically from 54K text-based trajectories. External LLM judgments identify candidate latent spans, model entropy provides a confidence signal, and a visibility audit restores steps judged necessary for decision-critical inspection. This procedure avoids manual labeling, but it introduces dependence on the quality and calibration of the external judges and on the assumption that low-entropy or judge-selected steps are appropriate candidates for latentization. The paper does not isolate the contribution of each curation signal in a full factorial study.

HybridRL and policy optimization over latent trajectories

Standard PPO- or GRPO-style objectives require likelihoods for sampled actions. Latent states in HybridAgent are deterministic outputs of HybridLink rather than sampled vocabulary tokens, so token-level likelihood ratios are undefined at latent positions. HybridRL addresses this through two linked arguments.

First, with HybridLink held fixed, latent transitions and mode transitions are deterministic conditional on the preceding trajectory. Tool observations are environmental outputs. Consequently, the likelihood of a hybrid trajectory factorizes over the text positions at which the model samples tokens:

$$\pi_\theta(\tau\mid x) = \prod_{t\in\mathcal{T}} \pi_\theta(y_t\mid x,\tau_{<t}).$$

Second, during policy updates the system replays the recorded latent inputs and tool observations while recomputing the text-token probabilities. This exact latent-context replay ensures that the likelihood of each sampled token is evaluated under the same hybrid prefix that produced the reward during rollout.

Figure 6: During HybridRL, increasing reward and tool use coincide with a shift from text generation toward latent computation.

The theoretical result is conditional on freezing HybridLink during RL and treating recorded latent inputs as fixed during differentiation. The update therefore trains the backbone to assign higher probability to text actions conditioned on recorded latent contexts, but it does not backpropagate through the causal dependence of those latent states on the current policy within the same rollout. The paper’s gradient-equivalence result is valid for the stated replay objective; it should not be interpreted as an unbiased gradient for a fully differentiable stochastic process in which latent trajectories are regenerated under every parameter update.

The reward combines answer correctness, formatting, and tool-use incentives. Removing correctness produces the largest degradation, reducing performance by 6.4%–17.8% across the reported benchmarks. Removing the tool reward has little effect on MATH500 but decreases GAIA by 11.2% and WebWalker by 3.5%, consistent with the reward being applied to trajectories using both Python and search.

HybridRL also learns a nontrivial allocation policy. Over training, the proportion of latent computation increases while reward and tool usage improve. This is a central empirical claim: the model does not merely use latent mode as a fixed compression mechanism; it learns to reserve text for external actions and expose selected intermediate decisions while moving more internal reasoning into latent space.

Accuracy across reasoning and agentic benchmarks

The evaluation spans mathematical reasoning, expert knowledge, medicine, multi-hop retrieval, web traversal, search-augmented QA, and general-purpose agentic tasks. The main comparisons use matched Qwen3 backbones and training budgets, alongside frontier systems and agentic frameworks.

At 8B, HybridAgent achieves 39.2 on AIME25, 43.3 on AIME26, 84.6 on MATH500, 48.0 on GPQA-Diamond, 75.3 on MedQA, and 32.0 on MuSiQue. At 14B, the corresponding results are 43.3, 45.8, 88.2, 55.1, 81.7, and 34.5. In each case, the HybridRL model exceeds the reported GRPO and ARPO baselines under the matched setup.

On agentic benchmarks, the 8B model reaches averages of 43.7 on GAIA, 42.5 on WebWalker, 14.4 on HLE, 22.5 on SealQA-S0, 35.8 on SealQA-Hard, and 20.0 accuracy with 40.7 F1 on DSQA. The 14B model reaches 52.4 on GAIA, 49.5 on WebWalker, 16.0 on HLE, 24.3 and 37.8 on the two SealQA splits, and 21.7 accuracy with 46.8 F1 on DSQA.

The reported 14B HybridAgent improvement over the strongest agentic baseline averages 17.4%. This comparison is informative because it includes text-based agents and agentic frameworks, but it should be interpreted with attention to implementation details: the model uses specialized infrastructure, tool-call limits, task-specific checkpoints, and external LLM components for search-page summarization and judging. The benchmark results therefore demonstrate the performance of the complete system rather than isolating HybridLink alone.

The 4B experiments suggest that the method is not restricted to the largest evaluated model. HybridAgent exceeds ARPO by an average of 2.0 percentage points over AIME25, AIME26, MATH500, and GPQA-Diamond. This result supports scale portability, although the evidence remains limited to three backbone sizes and one model family.

Test-time scaling and efficiency

HybridAgent improves not only single-sample accuracy but also test-time scaling. As the number of samples increases from pass@4 to pass@64, the hybrid models show a stronger upward trend than text agents trained with GRPO on the evaluated 100-question math and science set. The result indicates that latent reasoning does not prevent useful diversity across sampled trajectories and may make additional sampling more computationally tractable.

Figure 7: HybridAgent’s pass@k performance increases with additional test-time sampling and compares favorably with text-only RL agents.

The efficiency results are among the paper’s strongest claims. Relative to matched text agents, HybridAgent uses approximately 2.7x fewer text tokens, reduces total generation steps by up to 54%, and achieves reported inference speedups of up to 2.1x in the detailed analysis. The abstract reports a broader 1.8x–2.6x range across settings.

Figure 8: Latent spans reduce both the number of decoded text tokens and the total number of generation steps across model scales.

The cost analysis counts every text or latent step as one full backbone forward pass, then adds the cost of vocabulary projection or HybridLink. Under this accounting, estimated decoding compute falls from 51.2 to 13.9 TFLOP per question at 4B, from 62.5 to 17.2 TFLOP at 8B, and from 66.9 to 25.1 TFLOP at 14B. These correspond to reductions of 72.9%, 72.5%, and 62.5%. Estimated cost per million questions decreases from $359 to$98 at 4B, $439 to$121 at 8B, and $470 to$176 at 14B.

The implication is not simply that latent steps are individually cheaper: both modes invoke the backbone. The savings arise primarily because latent reasoning avoids repeated vocabulary decoding and produces shorter trajectories. However, the reported end-to-end serving advantage remains conditional. The authors explicitly exclude prompt-prefill, context-dependent attention, tool execution, and several possible memory-management costs. Since HybridAgent retains more latent steps in KV memory, long-context attention and cache bandwidth could reduce the practical advantage in deployments with very long trajectories.

Tool use and external auditability

HybridAgent’s text mode preserves tool use despite moving much of the reasoning into latent space. Across 8B and 14B, valid tool calls maintain a 99.7% execution-success rate. On questions involving at least one tool call, HybridAgent improves final-answer accuracy by 2.2%–44.1% relative to the matched GRPO agents, while useful tool-call rates increase by 4.5–7.7%.

Figure 9: HybridAgent preserves valid and executable tool calls while improving answer accuracy and the proportion of tool calls that produce useful evidence.

The authors also evaluate whether reducing visible text compromises oversight. HybridAgent exposes 43%–49% fewer text tokens than matched text agents: 302 versus 596 tokens at 8B and 284 versus 497 at 14B. Despite this reduction, the visible trace contains more key reasoning steps per 100 tokens, increasing from 0.57 to 0.72 at 8B and from 0.67 to 0.86 at 14B.

Monitoring performance remains comparable or better for weak monitors. Weak-monitor AUROC on MATH500 is 0.840 for HybridAgent versus 0.772 for the 8B text agent, and 0.860 versus 0.818 at 14B. Strong-monitor AUROC is nearly unchanged, at 0.961 versus 0.935 for 8B and 0.989 versus 0.990 for 14B. First-error localization reaches 99.2% at 8B and 98.1% at 14B, while reference-consistent error diagnosis remains between 97.2% and 97.6%. Targeted corrective hints improve fix rates over generic retries by 9.1 points at 8B and 5.4 points at 14B.

These results support a narrower and defensible claim: selectively exposing text can preserve several operational measures of monitoring and debugging while substantially reducing visible token volume. They do not establish that hidden latent reasoning is safe to omit from oversight. The evaluation observes only external monitors operating on visible traces, and the latent readout itself is produced using the system’s nearest-token mechanism. Whether this readout reliably exposes deception, reward hacking, or strategically obfuscated computation is not tested.

Limitations and open questions

The paper’s theoretical guarantees depend on restrictive conditions. Lossless working-memory continuation assumes exact preservation of KV entries and consistent inference configuration. HybridRL’s policy factorization assumes a fixed HybridLink and deterministic latent transitions, so the analysis does not cover jointly updated latent dynamics or stochastic latent policies. The replay procedure freezes latent inputs during differentiation, which may limit credit assignment through the latent computation itself.

The interpretability results also require careful qualification. Nearest-token cosine alignment and lexical overlap with the source question provide evidence of readable geometric structure, but they are not sufficient measures of faithfulness. A latent state can be mapped to plausible pseudo-text without that pseudo-text being the computationally decisive content. The intervention experiments demonstrate causal dependence on latent states, not causal faithfulness of their textual readouts.

The empirical comparison is broad but not fully architecture-agnostic. All primary models use Qwen3-Base backbones, the data are automatically curated with external LLMs, and several evaluations use task-specific checkpoints and infrastructure unavailable to ordinary text baselines. The reported speed and cost gains exclude prompt-prefill, external tools, and some long-context serving costs. In addition, the reported benchmarks do not directly test robustness under adversarial tool outputs, distribution shift in tool APIs, KV-cache corruption, or failures of the mode-transition mechanism.

Several questions remain open within the paper’s own framework. It is unclear how HybridAgent behaves when a decision-critical step is incorrectly assigned to latent mode, whether a latent trace can be audited without access to the provider’s HybridLink, and how performance changes when latent spans are compressed, quantized, or selectively evicted from working memory. It also remains unresolved whether jointly learning HybridLink during RL would improve credit assignment or destabilize the policy-factorization assumptions used by HybridRL.

Conclusion

HybridAgent presents a unified architecture for combining continuous latent reasoning with text-based tool interaction. HybridLink supplies the representation bridge, continuous KV memory preserves multi-turn hybrid context, HybridSFT addresses the latent train–inference mismatch, and HybridRL extends policy optimization to trajectories containing deterministic latent computation and sampled text actions.

Across the reported experiments, the method improves matched text and latent baselines while reducing decoded tokens, generation steps, and estimated decoding cost. Its most consequential empirical claim is that this efficiency does not require abandoning tool use or compact external auditability. The evidence supports HybridAgent as a technically coherent framework for hybrid generation, while leaving the faithfulness of latent readouts, the deployment cost of persistent hybrid memory, and policy optimization with trainable latent dynamics as central unresolved issues.