Most LLM agents work the way you’d expect: they think out loud. Every step of reasoning, every internal deliberation, gets tokenized and billed. It’s like paying for someone to narrate their entire thought process before they do anything.

A new paper from researchers at multiple institutions proposes something different. Hybrid Reasoning Agents keep the thinking part internal, in the model’s latent space, and only surface the actual actions as text. The thinking happens, but you don’t pay to serialize it.

How It Works

The architecture splits agent behavior into two modes. When the agent needs to reason about what to do next, it operates in latent space. The model processes information and makes decisions using its internal representations, without generating tokens. When it’s time to act (calling a tool, generating output, responding to the environment), it switches to text mode.

This isn’t just about cost savings. The paper reports performance improvements on several agent benchmarks. On WebShop, a simulated e-commerce environment where agents search for and purchase products, the hybrid approach outperformed standard text-based reasoning. Same story with HotPotQA, which requires multi-hop reasoning across different sources.

The methodology matters here. These aren’t cherry-picked examples. The researchers tested against established baselines using the same underlying models. The gains come from the architecture, not from model scaling.

Why Latent Space Reasoning Works

Text-based reasoning has a fundamental constraint: everything needs to be linearized. Complex multi-dimensional reasoning gets flattened into a sequence of tokens. That’s fine for some tasks, but it’s inefficient for others.

Internal representations don’t have that limitation. The model can maintain richer structures while it thinks. It only commits to the linearization when it needs to interact with tools or produce output.

There’s also a practical benefit: fewer tokens means faster iteration. When you’re debugging agent behavior or running evaluations, cutting the token count per decision cycle compounds quickly.

The Implementation Reality

The paper describes the approach, but it doesn’t ship ready-to-use code. Building this into an actual agent framework means solving some engineering problems. You need clean mode switching, good APIs for when to stay latent versus when to generate text, and tooling to inspect what’s happening during that internal reasoning.

That’s not impossible. It’s the kind of thing that shows up in agent frameworks once someone does the work. But right now, this is a research result, not a package you can install.

Tooling Updates

Speaking of things you can actually install: the AI developer tooling ecosystem keeps moving. WhatsApp MCP, a new Model Context Protocol server, lets Claude Desktop interact with WhatsApp messages. It runs on Cloudflare Workers, so there’s no server to maintain. Setup involves the usual MCP configuration dance, but once it’s running, you can query messages, send replies, and build workflows that bridge chat and AI tools.

Simon Willison released updates to a couple of his LLM plugins this week. The llm-tools-datasette plugin broke when LLM switched to httpx2, because it was using httpx without declaring the dependency. That’s fixed now. He also updated llm-echo, a debug plugin that echoes back prompts instead of hitting an actual LLM. The new version simulates token counts for tool calls and reasoning tokens, which makes it more useful for testing workflows without burning API credits.

And there’s Superlite, which bills itself as a faster alternative to Superpowers for handing specifications to AI agents. The pitch is that it’s lighter weight and more focused. Worth checking out if you’re building agent workflows and looking for tooling that doesn’t carry extra dependencies.

Where This Goes

Hybrid reasoning agents point toward a clearer architecture. Internal reasoning stays internal. Actions go through text interfaces that tools can consume. The boundary between thinking and acting becomes explicit instead of blurred.

That’s useful even if you never touch latent space reasoning yourself. It’s a better mental model for how these systems work and where the costs accumulate. And as agent frameworks mature, seeing research validate this kind of separation makes it more likely we’ll get cleaner APIs for both modes.

The research is at arxiv.org/abs/2610.18861. The WhatsApp MCP code is on GitHub. Simon’s LLM plugins are documented on his site.