Daily AI Paper

Modern language-model agents have become much more than chatbots. To solve difficult tasks, they increasingly need to call tools, inspect results, search the web, run code, and keep adapting based on what they observe. That makes them not just reasoners, but actors in an environment. The problem this paper tackles is that today’s agents still do almost all of that thinking in text. Text is easy to read and easy to connect to tools, but it is also verbose and expensive. On the other side, there is a growing line of work on latent reasoning, where the model carries out internal computation directly in continuous hidden space. That can be faster and more efficient, but those latent thoughts are usually trapped inside the model: they are hard to connect to tools, hard to supervise, and hard to inspect. The key idea in this paper is to stop treating those two modes as separate worlds. Instead, the authors propose Hybrid Reasoning Agents, or HybridAgents, which can move back and forth between latent reasoning and text-based interaction within a single generation process. The goal is a new kind of agent that can think in a richer internal medium when it wants to reason efficiently, but still switch to text whenever it needs to act externally, call a tool, or communicate with the outside world. To understand why that matters, it helps to place this work in the broader landscape. Standard LLM agents are built around autoregressive text generation. They produce tokens one by one, and those tokens may include tool calls, intermediate reasoning, and final answers. This is transparent, but it can be inefficient, because every internal thought has to be verbalized. Latent reasoning approaches take a different route: instead of decoding every step into text, the model feeds its own hidden states back into itself and continues computation in continuous space. This can reduce token usage and speed things up, but it introduces a gap between the model’s internal computation and the external interface. HybridAgents try to close that gap. The architecture has two main pieces. First is a lightweight module called HybridLink. Its job is to bridge the model’s last-layer hidden states back into the input embedding space, so that the agent can transition smoothly between text tokens and latent states. In ordinary latent reasoning, the model often reuses the hidden state directly as the next input, but that works best when everything stays inside latent mode. HybridLink makes the transition more natural for a pretrained language model by aligning the continuous internal representation with the input space the backbone already expects. The paper emphasizes that this module is lightweight, rather than a full new model. Second is a continuous working memory that carries the full hybrid trajectory across turns. That means the agent does not need to reconstruct everything back into tokens after each step. Instead, text, latent thoughts, and tool observations are all preserved in the same internal flow of key-value states across the Transformer. This is important because a real agent rarely completes its task in one shot. It reasons, calls a tool, observes output, reasons again, and so on. The working memory lets HybridAgent maintain that chain of reasoning without losing information between turns. The actual generation process is dynamic. In text mode, the agent behaves like a standard LLM and produces tokens normally. At some point, it can emit a special latent marker that acts as an entry point into latent mode. Once in latent mode, it continues computation in continuous space, using HybridLink to feed each latent step back into the next one. The latent span ends when the model reaches a corresponding exit condition, at which point it returns to text mode. The important point is that the model decides when to switch. The length and frequency of text and latent spans are not fixed in advance; they emerge during generation. The authors also note an interesting property: latent reasoning can be made directly inspectable by mapping latent steps back to their nearest token embeddings, which gives a human-readable pseudo-text view of what the model is doing internally. Because the architecture alone is not enough, the paper also introduces training methods specifically for hybrid reasoning. The first stage is HybridSFT, a supervised fine-tuning procedure designed to stabilize generation and tool use. The core challenge here is train-inference mismatch: the model must learn to coordinate with HybridLink and with its own latent thoughts, rather than only with ordinary text. HybridSFT uses a staged process and a curated hybrid data recipe to teach the backbone how to handle this mixed mode reliably. The second stage is HybridRL, a reinforcement learning method that scales agentic reasoning. Here the goal is not just to make the model better at one mode or the other, but to teach it when to think internally and when to act through text. The authors describe this as policy optimization over hybrid trajectories, using a factorized view of the policy and exact rollout replay. In plain terms, they are training the agent to make better decisions about mode switching while preserving the full hybrid context during learning. The experiments are broad. The authors evaluate HybridAgent on 11 benchmarks spanning mathematics, science, medicine, knowledge-intensive search, and challenging agentic reasoning. They instantiate the system at three model sizes using Qwen3-Base backbones at 4B, 8B, and 14B parameters. They compare against frontier LLM agents and against other frameworks that cover both text-based and latent methods. So this is not a narrow benchmark win on one task family; it is meant to test whether the hybrid design generalizes across reasoning and tool-use settings. The headline result is that HybridAgent improves average performance by 10.4% over the compared systems. Just as important, it does so more efficiently. The paper reports a 35.5% to 54.7% reduction in token usage, a 1.8x to 2.6x inference speedup, and a 2.7x to 3.7x reduction in computational cost. Those numbers matter because they suggest the model is not merely trading one kind of accuracy for another; it is getting both better reasoning and lower overhead. The efficiency gains are exactly what you would hope to get from shifting some internal work out of the verbose text channel and into latent computation. The authors also present analysis that helps explain why the gains happen. They find a division of labor between the two modes: HybridAgent tends to move more of the internal reasoning into semantically rich latent thoughts, while reserving text for external inspection and tool interaction. That is a useful result because it suggests the model is not randomly mixing modes; it is learning a meaningful strategy. Text becomes the interface to the world, while latent space becomes the workspace for deeper internal computation. There are also claims about transparency and reliability. Because latent steps can be mapped back into pseudo-text, the authors argue that the internal reasoning is more inspectable than in prior latent-only systems. And because the working memory preserves the full hybrid trace across turns, tool use and multi-step reasoning remain coherent without needing to reconstruct the whole process in token form. What should we be cautious about? First, this is still a model and training framework built on top of existing Transformer backbones, so its behavior depends on how well the hybrid interface and post-training stages generalize across domains and scales. Second, while the paper argues that latent reasoning is interpretable through nearest-token projections, that is not the same as full transparency; pseudo-text is still an approximation of what the model is doing internally. Third, the reported benefits come from a specific set of benchmarks and model families, so the broader picture will depend on how the method performs on other tasks, other backbones, and more demanding real-world agent deployments. Even with those caveats, the contribution is clear. This paper proposes a practical way to merge two previously separate ideas: efficient latent reasoning and tool-using text-based agents. Instead of forcing a model to choose one medium forever, HybridAgents let it switch dynamically between both. That makes the agent more efficient, potentially more capable, and more inspectable. If this line of work continues to mature, it could point toward a new generation of agents that do not just speak in text, but think in a richer internal language and speak only when it needs to.