An 8B Agent That Thinks Without Writing Tokens Beats GPT-5.6 Luna on GAIA. Not on HLE

• Book: RAG Pocket Guide
• Also by me: Thinking in Go (2-book series) — Complete Guide to Go Programming + Hexagonal Architecture in Go
• My project: Hermes IDE | GitHub — an IDE for developers who ship with Claude Code and other AI coding tools
• Me: xgabriel.com | GitHub

An 8-billion-parameter agent does part of its thinking without writing a single token, and on the GAIA agent benchmark it scores 43.7 to GPT-5.6 Luna's 37.9. Those numbers are the authors' own, reported in Table 1 of the Hybrid Reasoning Agents paper. The same table puts it at 14.4 on Humanity's Last Exam, where Luna scores 29.0.

The paper went up on arXiv on October 13, 2026 and made the Hacker News front page on October 18, with 168 points and 101 comments by the time this was written. The weights, training data and code are public under MIT. Both halves of that scorecard matter if you are thinking about using it.

What Stanford and Together AI released

The authors list affiliations at Stanford, UIUC and Together AI. The GitHub repo holds the method, the generation engine, both post-training stages, batch inference and an inspector for the latent thoughts, all MIT-licensed.

Two agents are on Hugging Face: HybridAgent-8B-Agentic and HybridAgent-14B-Agentic. Both start from Qwen3 base models, per the repo README. They call a Python interpreter and a web search tool across turns, and search needs a Tavily API key (model card). The SFT and RL datasets are published too.

The abstract reports, across 3 model scales and 11 benchmarks, an average 10.4% improvement, 35.5% to 54.7% fewer tokens, 1.8x to 2.6x faster inference and 2.7x to 3.7x lower cost.

How the agent goes quiet

A normal agent reasons in text. Every thought is a token you pay for, and every token lands in your logs.

HybridAgent can leave text. When the model emits a special <latent> token, the next steps skip decoding: the last-layer hidden state goes through a small residual adapter the authors call HybridLink and is fed straight back in as the next input embedding (paper, Eq. 4). The paper estimates HybridLink at roughly 10M parameters for a 4B model, and the count grows with hidden size. The latent span ends when HybridLink's output lands nearest to the </latent> token embedding. Nothing fixes the span length; the model decides as it goes.

Then it acts in plain text: a tool call, a search query, an answer. Between turns, the agent keeps the KV cache of everything so far (prompt, text, latent steps, tool results) and resumes from it, instead of re-encoding the trajectory as tokens (paper). HybridRL is the stage that teaches it when to think quietly and when to write.

Read the scorecard row by row

The 10.4% is an average. The rows are uneven. From Table 1:

The small agents win the web-navigation and multi-hop search rows by wide margins. On HLE, a hard knowledge-and-reasoning exam, the frontier models score roughly double. On DeepSearchQA, Luna still leads. If your workload looks like HLE, the averaged headline does not describe you.

One more row from the same table matters for the headline. ARPO, a text-based 8B agent trained with multi-turn tool-use RL and no latent mode, already scores 38.8 on GAIA and 32.0 on WebWalker (Table 1). That is above Luna on both, narrowly on GAIA. So an 8B agent beating Luna on GAIA is not unique to the latent mode. What the latent mode adds is the margin: from 38.8 to 43.7 on GAIA and from 32.0 to 42.5 on WebWalker.

The cost number needs the same care. Table 9 prices compute, not an API bill: "Monetary costs assume $2.50 per H100-hour and 10% utilization of peak BF16 throughput" (paper). Each latent step is charged as one full forward pass, so thinking without tokens is not free. The estimates also "exclude prompt prefill, context-dependent attention, and external tool execution." On those terms the 8B agent drops from $439 to $121 per million questions. Your search API bill and your prefill are on top of that.

You can't log what was never written

Most agent observability today reads text: the reasoning, the tool calls, the final answer. A latent span has no text to read. One commenter in the HN thread asked: "Monitorability and safety, no? This results in lower volume or less accurate text reasoning traces, right?" (HN).

The authors do offer a window. Each latent step can be mapped to its nearest token embedding, which yields what the paper calls pseudo-text, and its readability score is the average best cosine match against the vocabulary (paper, Appendix F). The repo ships an inspector that writes those spans to an HTML report (README).

Nearest-token decoding tells you which word the hidden state points closest to. It does not prove that the word is what the step computed. The paper's Appendix B.1 also describes small errors compounding over a long latent span, "gradually eroding the semantic coherence of the latent trace" (paper). If your review process depends on reading an agent's reasoning, a latent agent gives you less of it: the steps you can't read are the same steps that save the tokens.

Trying it today

The README's quick start, split to fit:

git clone https://github.com/togethercomputer/HybridAgent.git
cd HybridAgent
conda create -n hybridagent python=3.11 -y
conda activate hybridagent
pip install torch==2.11.0 \
  --index-url https://download.pytorch.org/whl/cu128
pip install -r requirements.txt
pip install -e .
cp .env.example .env   # TAVILY_API_KEY for the search tool

And the inspector, also from the README:

python -m interpretable_latent_mode \
  --model togethercomputer/HybridAgent-14B-Agentic \
  --question "How many trailing zeros does 100! have?" \
  --output report.html

Before you plan around it: the model card says loading with transformers alone gives you a text-only model; latent mode and tools need the HybridAgent code. No inference provider hosts it yet. And the authors write that verl and vLLM "do not directly support multi-turn hybrid generation," so they extended their own stack (paper). Training is heavier still: the README recommends 32 GPUs for HybridRL.

One early report in the HN thread came from a commenter who ran the 14B model and said "it looped on variations of the same paragraph for five minutes before running out its turn budget," suspecting a llama.cpp incompatibility. Given the model card's warning, my reading is that a run outside the HybridAgent engine is not testing the hybrid part at all. I haven't run it myself.

Is a cheaper agent worth reasoning you can only read through a projection? For search-heavy jobs where you check the answer and not the path, maybe. For anything you have to audit, I'd want the text. Where do you land?

If this was useful

HybridAgent's biggest wins are on search and multi-hop retrieval tasks, and that's a reminder that what the agent fetches still decides most of the answer. The RAG Pocket Guide covers that layer: retrieval, chunking and reranking patterns you can apply whether the model on top thinks in text or in hidden states.

If you run several coding agents side by side, I build Hermes IDE, a console, free to download, that gives each one its own terminal and worktree, on macOS, Windows and Linux (GitHub).