8B Agent Beats GPT-5.6 Luna on GAIA with Latent-Space Reasoning, but Crumbles on HLE

Stanford, UIUC, and Together AI have jointly released HybridAgent, which lets an 8-billion-parameter model skip text generation for some reasoning steps and perform computation directly in latent space. According to Table 1 in the paper, the model scores 43.7 on the GAIA benchmark, surpassing GPT-5.6 Luna's 37.9, but it scores only 14.4 on the HLE knowledge-reasoning exam—less than half of Luna's 29.0. This uneven performance reveals the real boundaries of latent-space reasoning.

How latent-space reasoning works

Every reasoning step in a traditional agent is emitted as text tokens—billable, loggable, auditable. HybridAgent stops decoding when it detects a special <latent> token and feeds the last-layer hidden state through a roughly 10-million-parameter HybridLink adapter directly back as the input embedding for the next step (paper Eq. 4). The model decides on its own when to terminate the latent segment: it exits when the output is closest to the </latent> token embedding.

The model then resumes text mode to execute tool calls or produce an answer. Across turns, the full KV cache is preserved (including latent steps), avoiding the need to re-encode the trajectory as tokens. The HybridRL training stage teaches the model when to think silently and when to start writing.

The direct benefits of this mechanism appear in the paper's abstract data: an average improvement of 10.4% across 3 model scales and 11 benchmarks, a 35.5% to 54.7% reduction in token usage, 1.8× to 2.6× faster inference, and 2.7× to 3.7× lower cost.

KV cache (Key-Value Cache) is a core optimization in Transformer autoregressive generation. When generating text token by token, the model must recompute attention over the historical sequence at each step, with cost growing quadratically with sequence length; the KV cache retains the key (Key) and value (Value) matrices already computed at each layer, so subsequent steps only need to compute the key-values for the new token and concatenate them, reducing per-step computation to linear complexity. Preserving the full KV cache across turns (including latent steps) means the agent does not need to re-encode prior trajectories as tokens during multi-turn interaction, which is one of the important sources of cost savings in latent mode; however, the cache must reside in GPU memory, and the longer the context, the higher the memory footprint.

Hidden state refers to the dense vector output by a given layer (usually the last layer) of the model at a specific position, with dimensionality equal to the model's hidden dimension. It aggregates the internal representation of the preceding context at that position and is typically projected through the output layer onto the vocabulary to predict the next token. HybridAgent's approach skips this projection and sampling step, feeding the last-layer hidden state through the adapter directly back as the input embedding for the next step, thereby continuing computation in semantic space without passing through the discrete text bottleneck.

The report card needs to be read line by line

The average 10.4% improvement masks huge divergence across benchmarks. From Table 1 in the paper:

Benchmark	HybridAgent 8B	HybridAgent 14B	GPT-5.6 Luna	Kimi K3
GAIA	43.7	52.4	37.9	41.7
WebWalker	42.5	49.5	11.0	10.0
HLE	14.4	16.0	29.0	31.4
DeepSearchQA (acc)	20.0	21.7	23.3	21.7

The small model leads by a wide margin on web navigation and multi-hop search tasks, but on high-difficulty knowledge-reasoning exams like HLE, the frontier model's score nearly doubles. Luna still has the edge on DeepSearchQA. If your workload resembles the HLE type, the average numbers do not apply to you.

GAIA, WebWalker, HLE, and DeepSearchQA evaluate different capabilities. GAIA targets general AI assistants, with questions mostly being real-world tasks that require web browsing, file parsing, and multi-step tool use, examining the agent's planning and tool-use chain. WebWalker focuses on web navigation and multi-hop information retrieval, measuring the agent's ability to jump between sites and locate information layer by layer. HLE (Humanity's Last Exam) is a high-difficulty closed-book knowledge-reasoning exam covering mathematics, physics, the humanities, and other disciplines; it relies more on the disciplinary knowledge stored within the model and deep reasoning rather than retrieval or tool operation. DeepSearchQA, meanwhile, evaluates the accuracy of multi-hop deep-retrieval question answering. Understanding the differences among these four is what explains why a small model can lead on GAIA and WebWalker yet fall nearly half behind on HLE—the former rewards retrieval and tool orchestration, while the latter rewards knowledge and reasoning depth, and latent mode optimizes precisely the cost of the reasoning steps that the former depends on.

It's not just latent space that beats Luna

There is a key control in the same table: ARPO—a pure-text 8B agent without latent mode—already scores 38.8 on GAIA and 32.0 on WebWalker, both slightly higher than Luna.

This means the 8B model surpassing Luna on GAIA is not solely attributable to latent mode. What latent mode truly contributes is the increment: GAIA rises from 38.8 to 43.7, and WebWalker jumps from 32.0 to 42.5. This portion of the improvement is where the value of the HybridLink mechanism lies.

The cost figures likewise require careful interpretation. Table 9 estimates computational cost rather than API bills: assuming $2.50 per H100-hour and 10% utilization of peak BF16 throughput, each latent step is billed as one full forward pass—thinking without writing tokens is not free. The estimate also excludes prompt prefill, context-dependent attention, and external tool execution. Under this accounting, the cost per million questions for the 8B agent drops from $439 to $121; your search API bill and prefill overhead must be added on top separately.

Thoughts that cannot be recorded: the observability cost

Current agent observability systems rely almost entirely on text: reasoning chains, tool calls, final answers. The latent segment has no text to read. In a Hacker News thread, a commenter directly raised the question: "What about monitorability and safety? Won't this lead to fewer or less accurate textual reasoning traces?"

The authors provide a window: each latent step can be mapped to the nearest token embedding, producing so-called "pseudo-text," with a readability score taken as the mean of the best cosine matches over the vocabulary (paper Appendix F). The inspector included in the repository can output latent segments as HTML reports.

But nearest-token decoding can only tell you which word the hidden state points toward; it cannot prove that the word is what the step actually computed. Paper Appendix B.1 also describes the problem of small errors gradually accumulating over long latent segments, "gradually eroding the semantic coherence of the latent trajectory." If your review process depends on reading the agent's reasoning process, a latent agent gives you less—the steps you cannot read are precisely the steps that save tokens.

ReAct-style textual reasoning traces are the cornerstone of current agent observability: the model writes "thought—action—observation" step by step in natural language, and human reviewers, logging systems, and safety filters all read these texts directly. Latent steps bypass this layer, equivalent to moving part of the thinking process out of the logs. Common industry auditing methods—including reasoning-chain replay, text-based jailbreak and harmful-behavior detection, and failure attribution analysis—all rely heavily on readable intermediate text; as such steps decrease, detection coverage declines accordingly, requiring replacement methods such as hidden-state probes and activation monitoring, which are not yet mature. Cosine-similarity nearest-neighbor decoding is how the paper's pseudo-text window is implemented: compute the cosine similarity between the latent vector and the embedding of each token in the vocabulary, and take the closest as an approximation of "what this step is saying." It is essentially a projection-based interpretation, reflecting the vector's orientation in embedding space rather than the semantic content the model actually encodes or computes at that step, so it can only serve as a rough clue, not as reasoning evidence.

Barriers to entry and early feedback

The repository releases weights, training data, and code under the MIT license. Both models—HybridAgent-8B-Agentic and HybridAgent-14B-Agentic—are based on Qwen3 backbones and can call a Python interpreter and a web search tool (requires a Tavily API key).

Limitations to face squarely: the model card explicitly states that loading with transformers alone yields a pure-text model, and latent mode and tool calling must go through the HybridAgent code stack. Currently no inference provider hosts the model. The authors also note that verl and vLLM "do not directly support multi-turn hybrid generation," so they extended their own stack. The training side is heavier still: the README recommends 32 GPUs for HybridRL.

In the HN thread, one commenter reported that when running the 14B model it "looped on variants of the same paragraph for five minutes until exhausting the turn budget," suspecting incompatibility with llama.cpp. Combined with the model card warning, running outside the HybridAgent engine simply does not test the hybrid reasoning part at all.

Trade-off judgment

For search-intensive tasks—where you only check the answer and do not audit the path—a cheaper latent agent is attractive. For any scenario requiring auditing, a readable textual reasoning chain remains irreplaceable. HybridAgent's advantages on GAIA and WebWalker remind us: what the agent retrieves still determines most of the answer's quality, and latent mode saves the cost of the thinking process, not the cost of knowledge itself.