# HybridAgent tests latent reasoning alongside text-based tool use

> A new preprint and released code show how HybridAgent alternates latent reasoning with text tool use. Its measured gains come from the authors' benchmark setup.

By BIG CHANGE Editorial

Published: 2026-10-19T07:00:34.991Z
Updated: 2026-10-19T07:00:34.991Z
Canonical: https://bigchange.ai/blog/hybridagents-latent-reasoning-text-tool-use-paper

![Conceptual charcoal illustration of a continuous accordion paper strip with dark folded sections and completely blank pale sections.](https://bigchange.ai/api/media/file/hybridagent-latent-text-accordion-concept-v2.png)
AI-generated conceptual illustration by BIG CHANGE; no actual model trace, architecture or test result is depicted.

An agent that calls a search engine has to express the query in text and read the result. Its private reasoning need not follow the same format. In an [October 13 preprint](https://arxiv.org/html/2610.18861v1), researchers from Stanford, the University of Illinois Urbana-Champaign, Together AI and Meta describe HybridAgent, a system that alternates continuous internal states with text for tool calls, observations and answers. They have released research code and two agentic checkpoints. The reported performance and efficiency results come from the authors' experiments, not an independent replication or a deployed service.

## The big change

- **What changed:** HybridAgent gives a language-model agent a way to move between internal continuous-state steps and ordinary text during one task. Text remains the interface for search, Python and the final answer.
- **Why it matters:** Developers studying agents can examine whether every intermediate step needs to be written out. The authors' matched experiments suggest fewer generation steps for their method, while the public code makes its implementation inspectable. Neither establishes a lower bill for an operating service.
- **What to watch:** Independent runs with the released checkpoints can test whether the measured advantage survives different tasks and tool costs. The harder inspection question is whether the readable words recovered from a latent state faithfully describe how an answer was reached.

## How the switch works

In normal text mode, the model generates tokens. When it emits a special `<latent>` token, a small component called HybridLink maps the model's last hidden state back into its input space. The system feeds the resulting continuous vector into the next step without first turning it into a word. It returns to text mode when a nearest-token comparison identifies the `</latent>` marker. The model can then write a tool call or its answer. The paper describes a persistent key-value cache that carries text, latent steps and tool observations through subsequent turns. [The architecture and transition rules are in Sections 3 and 4 of the preprint](https://arxiv.org/html/2610.18861v1).

This requires more than attaching an adapter to a pretrained model. The authors first convert text demonstrations into mixed text and latent training sequences, then use supervised training to teach the backbone and HybridLink to operate together. A reinforcement-learning stage trains the resulting agent on reasoning and search tasks. In that stage, the authors update probabilities at sampled text positions and replay the recorded latent inputs. The paper says its training data comprise 54,000 converted demonstrations, followed by separate sets of 12,000 deep-reasoning examples and 1,000 agentic search examples. [Training and data details](https://arxiv.org/html/2610.18861v1).

## What the benchmarks measured

The main evaluation reports 8B and 14B versions built on Qwen3-Base across 11 benchmarks. Six cover math, scientific or medical knowledge and multi-hop questions; five emphasize search and agent tasks. A separate appendix tests the 4B version on four benchmarks: AIME25, AIME26, MATH500 and GPQA-Diamond. The authors compare against text-trained agents using the same backbones and training data, latent-reasoning methods, frontier agents and tool-use frameworks. Those groups serve different comparison purposes. In the matched 14B reinforcement-learning comparison, for example, HybridAgent scores 88.2% on MATH500 against 87.0% for the text agent trained with ARPO. On the GAIA average, the paper reports 52.4% for HybridAgent 14B and 43.7% for that ARPO baseline. These are benchmark results under the authors' setup, not a general ranking of deployed agents. [Main tables, 4B appendix and baseline definitions](https://arxiv.org/html/2610.18861v1).

The setup matters. The paper uses checkpoints trained on deep reasoning for the math evaluations and checkpoints trained on agentic search for the knowledge and agentic evaluations. It says inference used temperature 0.6, top-p 0.95 and top-k 20, with budgets counting both text tokens and latent steps. It allowed 4,096 steps on math and knowledge tasks and 24,000 on harder agent tasks. Latent spans ran for at least 16 and at most 256 steps; trajectories had tool-call limits. The tools were a sandboxed Python interpreter and live search, with a model also used to summarize search pages and judge outputs. The authors report training and inference on 32 H100 GPUs. Different tool services, retrieval results or operating conditions could change a comparison. [Experimental setup](https://arxiv.org/html/2610.18861v1).

The abstract's 10.4% performance improvement refers to comparisons with corresponding text and latent baselines at the reinforcement-learning stage under matched model sizes and training budgets. It should not be read as a universal improvement over every frontier agent. The paper also reports results from five independent runs for its main agentic table, with an average standard deviation of 0.014 in accuracy. [Results and table caption](https://arxiv.org/html/2610.18861v1).

## The efficiency claim has a narrower denominator

The paper reports 2.7 times fewer text tokens and up to 54% fewer total generation steps in its comparison with text-based baselines. Its abstract gives a 1.8 to 2.6 times inference speed range and 2.7 to 3.7 times lower estimated cost. Latent steps still require model computation. The authors' cost table charges each text or latent step for a full backbone forward pass and estimates one million answers using an H100 price of $2.50 an hour at 10% of peak BF16 throughput. For the 8B backbone, that calculation moves from 62.5 to 17.2 trillion floating-point operations per question and from $439 to $121 per million questions. [Efficiency section and cost table](https://arxiv.org/html/2610.18861v1).

The same appendix explicitly excludes prompt processing, attention costs that vary with context, and execution of external tools. Search calls, hosting and other service costs are therefore outside that dollar comparison. The figures are useful evidence about the authors' measured generation paths and stated compute model, but they do not establish the cost of running a complete agent service.

## Readable latent spans still need scrutiny

HybridAgent can display a pseudo-text readout by mapping each latent step to its nearest token embedding. The [repository's example](https://github.com/togethercomputer/HybridAgent) shows such readouts alongside actual search and Python calls. In a separate paper experiment, changing or replacing latent vectors reduces MATH500 accuracy, which supports the claim that those states affect the answer. It does not show that the nearest words give a complete or faithful account of the computation. [Latent intervention table](https://arxiv.org/html/2610.18861v1).

The authors also test how useful the visible text is for external monitoring on 560 math problems. Their table reports fewer visible text tokens for HybridAgent than for matched text agents, alongside several model-judged monitoring and debugging measures. Some measures improve; the strong-monitor AUROC at 14B is 0.989 for HybridAgent and 0.990 for the text agent. These tests evaluate particular monitors and tasks. They cannot establish general transparency or safety, especially for hidden latent spans. [Auditability experiment](https://arxiv.org/html/2610.18861v1).

## What is available now

The [MIT-licensed repository](https://github.com/togethercomputer/HybridAgent) includes the hybrid generation engine, Python and search tools, supervised and reinforcement-learning pipelines, batch inference and a pseudo-text inspector. The authors link public [8B](https://huggingface.co/togethercomputer/HybridAgent-8B-Agentic) and [14B](https://huggingface.co/togethercomputer/HybridAgent-14B-Agentic) **agentic** checkpoints, plus training datasets. The paper's mathematical evaluations used separately trained deep-reasoning checkpoints; the README's released-model list identifies the two agentic checkpoints. Each public checkpoint includes the backbone and HybridLink weights. Its model card says loading the backbone through Transformers alone yields a text-only model; latent generation and tool use require the project code.

The README recommends 8 or 16 GPUs for supervised training and 32 GPUs across four nodes for its agentic-search reinforcement-learning launcher. Its installation instructions include a search API key. Those are meaningful requirements for anyone attempting the documented research pipeline. BIG CHANGE has inspected the paper, repository and model cards; it has not run the code, downloaded the checkpoints or reproduced the benchmarks.

## Sources

- [Zou et al., Hybrid Reasoning Agents, arXiv:2610.18861v1 (2026-10-13)](https://arxiv.org/html/2610.18861v1) — Primary preprint. Sections 3–6 and Appendices E, G, H establish method, training, benchmarks, 32-H100 setup and cost assumptions. Author results are not independent replication; the dollar estimate excludes prefill, context attention and tools.
- [Together Computer, HybridAgent code and README](https://github.com/togethercomputer/HybridAgent) — Official MIT-licensed research implementation. README lists engine, SFT/RL pipelines, 8B/14B checkpoints, Tavily key, 8/16-GPU SFT and 32-GPU search RL recommendations. BIG CHANGE did not run it.
- [Together Computer, HybridAgent-8B-Agentic model card](https://huggingface.co/togethercomputer/HybridAgent-8B-Agentic) — Official public 8B checkpoint card. Describes backbone and HybridLink weights; hybrid generation and tool use require repository code.
- [Together Computer, HybridAgent-14B-Agentic model card](https://huggingface.co/togethercomputer/HybridAgent-14B-Agentic) — Official public 14B checkpoint card. Same code requirement; research checkpoint, not evidence of a deployed service.