Hybrid Reasoning Agents (HybridAgent): Latent-Space Thinking With Text-Based Tool Use

Hybrid Reasoning Agents (HybridAgent) is a new arXiv paper that proposes letting an LLM agent reason in continuous latent space while still acting in the external world through text. The paper reports that this hybrid approach improves benchmark performance by 10.4% over frontier LLM agents and agentic frameworks spanning both text-based and latent methods, while cutting token usage by 35.5%–54.7%, speeding up inference by 1.8x–2.6x, and reducing cost by 2.7x–3.7x.

The paper is arXiv:2610.18861v1 [cs.CL], submitted 13 October 2026 and announced 14 October 2026. It is 45 pages with 12 figures, and lists Jiaru Zou, Yunzhe Qi, Sirui Chen, Federico Bianchi, Shang Zhu, Pan Lu, Jingrui He, and James Zou as authors. Code and data are published at github.com/togethercomputer/HybridAgent.

The core problem the paper addresses

Text-based LLM agents are transparent and tool-capable, but they pay a token cost for every internal reasoning step. Latent reasoning is cheaper and more expressive internally, but it has no native tool access and no reasoning transparency. HybridAgents are designed to keep both properties at once.

The abstract states the motivation directly: "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." The proposed system "dynamically navigate[s] between latent reasoning and text-based interaction throughout a unified generation process."

How the architecture works: HybridLink and continuous working memory

HybridAgent has two architectural components that make mode switching possible within one generation pass.

HybridLink is a lightweight module that enables seamless transitions between text mode and latent mode. It is the mechanism the backbone model learns to coordinate with during training.

Continuous working memory preserves lossless hybrid context across multiple turns. Because the memory is continuous rather than tokenized, latent thoughts are not discarded when the agent switches back to text — and the paper claims latent thoughts remain "directly inspectable."

Together these designs are intended to "preserve tool-integrated agentic capabilities while making latent thoughts directly inspectable," according to the abstract.

Training: HybridSFT then HybridRL

The paper introduces two dedicated post-training algorithms for hybrid reasoning.

HybridSFT stabilizes tool-integrated hybrid generation by teaching the backbone model to coordinate with HybridLink. In other words, supervised fine-tuning is used to make the text/latent switching behavior reliable before reinforcement learning is applied.

HybridRL then scales reasoning by learning when to think in latent space and when to act through text. The policy being learned is a routing decision: latent mode for internal reasoning, text mode for tool calls and external interaction.

Reported results

HybridAgent was evaluated at three model scales across 11 benchmarks covering mathematics, science, medicine, search, and agentic reasoning. The headline numbers reported in the abstract are:

• +10.4% performance versus frontier LLM agents and agentic frameworks spanning both text-based and latent methods
• 35.5%–54.7% token reduction
• 1.8x–2.6x faster inference
• 2.7x–3.7x cost savings

The paper's own evaluation section is at arxiv.org/html/2610.18861v1#S5.

Where to find the code, models, and data

A Hacker News commenter collected the release links in one place: the code is at github.com/togethercomputer/HybridAgent, the models and data are in a Hugging Face collection under the togethercomputer organization, and the evaluations are in section 5 of the HTML version of the paper. The first author also posted an announcement thread on X at x.com/Jiaru_Zou/status/2110400256647340476.

The Hacker News discussion: monitorability is the elephant in the room

The most substantive criticism in the thread concerns alignment and interpretability. The argument is that latent reasoning removes the chain-of-thought text that labs currently rely on to monitor model behavior.

One commenter laid out the case at length: "The consensus from the labs has been that CoT monitorability is a central tool for alignment. Sure, it's imperfect (models can exhibit deceptive CoT). But given how difficult mech interp is, it's the best we have." The same commenter noted that the paper allows latent traces to be read by projecting them into nearby tokens, but argued that this is lossy: "you're throwing out a lot of information in the full vector, with no way to interpret it. You're just reading some sort of approximation." Their central complaint was that the paper "doesn't even really engage with that discussion at all."

A related comment framed the work as a deliberate departure from prior restraint: "wasn't this explicitly taboo in the AI circles? using latent space for thinking is an obvious idea and has been known for ages. the frontier labs and the research community in general avoided an arms race in this direction due to interpretability and alignment concerns."

Another commenter compared it to earlier looping work: "In terms of safety and alignment, how is this different from looping or increasing the depth?" A separate comment asked whether running multiple passes before emitting thinking tokens "increases their capacity for deception."

Not everyone in the thread treated the safety framing as decisive. One commenter wrote simply, "This is the way. But now we also need new tools and techniques to audit intent. The last thing we want is models turning on us 'for our own good'." Another observed that latent reasoning means "welcome thinking tokens, buy buy observe-ability" — a tradeoff rather than a disqualifier.

"The Most Forbidden Technique"

Several commenters reacted to the latent-reasoning idea as a known-but-avoided research direction. One wrote, "Oh cool, it's the Most Forbidden Technique," and another quoted a line about "the forbidden technique from the classic novel Do Not Build The Forbidden Technique." The joke reflects a real observation in the thread: latent reasoning is an obvious extension of how chain-of-thought models work, and the reason it was not widely pursued is the monitorability concern described above.

Hands-on reports: the released models looped in local inference

Two commenters reported that the released HybridAgent weights failed in practice on consumer tooling.

One ran the 14B model in llama.cpp using an 8-bit quantization from bartowski: "it looped on variations of the same paragraph for five minutes before running out its turn budget, in response to a pretty simple chat request that other similar-sized models (e.g. Gemma 4 12B) have no trouble with, a web search and data summarization task." The same commenter then tested the BF16 version and reported "Same looping in BF16. So, probably have to wait on a llama.cpp update." They also noted the model "put the data into a Markdown table during its reasoning phase" despite a prompt asking for CSV output.

A second commenter tested an IQ4_XS GGUF build of the 8B model with the question "Who is the pope?" and reported an unbounded repetition loop:

Okay, the user is asking who the pope is. The pope is the leader of the Catholic Church. The current pope is Pope Francis, who became pope in 2013 after Pope Benedict XVI resigned. There's no indication of a change since then, so the answer is Pope Francis. Okay, the user is asking who the pope is...

That commenter also gave the model a counterfeit-ball weighing puzzle and reported it could not solve it, while adding the caveat that "no 8B model seem to be able to solve it" either.

These are individual user reports on specific quantizations and runtimes, not results from the paper. The paper itself reports strong benchmark numbers at three model scales.

Architecture questions raised in the thread

Several commenters probed design choices that the abstract does not fully answer.

Why loop only from the last layer? One commenter asked: "What if the model can guess that the transformed needed to answer the question better resides in layer 6, and you're at layer 15 out of 128?"

Why not reason latently while generating text? Another suggested widening the input embedding to accept both the post-HybridLink latent vector and a token embedding, so the model reasons latently even in text mode: "After all, you're paying essentially the full cost of running the latent-mode model while generating text, so why not let it latently reason at the same time?" They also noted the alternative of simply adding the vectors, since "everyone seems to have good results from munging vectors together with plain addition."

How does latent reasoning become text? One commenter asked directly: "How does it convert latent reasoning into human readable text?"

How does it compare to looped transformers? A commenter asked how HybridAgent differs from "Astra's looped transformer," which also reasons in latent space. No answer appears in the provided thread.

Model-selection and reproducibility complaints

One commenter wished the work had been built on a newer base model: "I wish they did it on Qwen3.5 though, because their beefed up Qwen3 8B is still way worse than Qwen3.5 9B." Another wanted to see the method applied to a 27B model whose reasoning output "tends to include lots of restatement, which I guess would be more likely to be kept in latent space with this hybrid reasoning."

A separate commenter noted that the evaluation set references older models, calling it "very nostalgic to hear some of these."

Philosophical objections to the word "reasoning"

A recurring theme in the thread is disagreement over whether latent computation should be called thinking. One commenter argued that LLMs are "just giant neural networks producing logits. There is no thinking. Its a function that takes ~500k words, and returns some words based on those probabilities." Another wrote that "stochastic processes can't reason, its simply not how they work. The output may have the appearance of a reasoned response, but that is not even synthetic reasoning."

Other commenters took the opposite view on the underlying idea. One noted that "there is no reason to assume thinking in words is the right granularity, or will stay the right granularity." Another observed that thinking silently changes what is thinkable: "if i would think aloud, that would most probably affect what or how i think. thinking silently allows me to have all kind of thoughts that could seem or be inappropriate when said loud." A further comment suggested latent memory could improve consistency: "This idea of models being able to keep latent-space ideas in memory while generating text might actually help the issue of inconsistent 'mental models' during text generation."

Terminology: is the agent the thing that thinks?

One commenter objected to the paper's framing of agents as reasoning entities: "I'm noticing a notion where thinking and reasoning is being shifted to agent from the model... I think it is better to leave agent as just an agent, separate from LLM. Agents don't think or reason about things. Agents help with action. LLM is what thinks and reasons."

Open questions the thread leaves unresolved

The Hacker News discussion surfaces several questions the paper's abstract does not settle:

• Whether latent reasoning traces are genuinely inspectable, or only inspectable through a lossy projection into nearby tokens.
• Whether the reported 10.4% performance gain holds when the base model is a newer generation than the one used in the paper.
• Whether the looping failures reported by two users are a llama.cpp compatibility issue, a quantization artifact, or a property of the hybrid generation process itself. One of the two users tested BF16 and still saw looping, which weakens the quantization explanation but does not rule out a runtime issue.
• How HybridAgent relates to prior latent-reasoning architectures such as looped transformers.
• Whether latent reasoning should be treated as a monitorability regression relative to text chain-of-thought, and what auditing tools would replace the lost text traces.