Wordless reasoning improved the AI agent’s answers by 10% and cut costs nearly fourfold.

The Agent Thinks Without Words—and Still Knows How to Use Tools

An AI agent faces a trade-off. If it reasons in text, its thinking is easier to inspect, but long chains of words take time and computing power. If it reasons in the model’s internal representation space, it can work faster—but its reasoning is harder to understand, and tool calls still have to be written out in text.

The authors propose combining both modes in a single agent. It handles internal steps in a hidden space, then switches to text to interact with the outside world—for example, to search the web or run code. The system decides for itself when to use each mode.

In tests covering math, science, medicine, and search tasks, HybridAgent was more accurate than comparable text-based agents. It also used 35.5–54.7% fewer text tokens and, according to the authors, ran 1.8–2.6 times faster.

Two Modes for One Task

A conventional language agent builds its entire response from tokens: its reasoning, tool requests, and final answer. In the hybrid approach, some reasoning happens without being converted into ordinary words. The model takes the internal representation of the current step, transforms it, and feeds it back in. It can then continue reasoning without writing down every intermediate step.

To switch between modes, the authors added a small module called HybridLink. It connects the model’s internal representations to the space where it processes input tokens. In text mode, the agent generates ordinary words. In hidden mode, it loops its internal representations back in. Special markers indicate where a hidden segment begins and ends.

External actions remain text-based. To search or run a program, the agent writes a tool call, receives the result, and continues. The roles are thus divided: hidden mode handles internal reasoning; text mode handles actions and human review.

HybridAgent switches between internal reasoning in a hidden space and text for tool calls.

How the Agent Keeps Track of Context

For a multistep task, switching modes isn’t enough: the agent also has to remember what happened earlier. A conventional text-based agent can add tool responses to its text history and reread it at the next step. But hidden representations can’t simply be inserted into that history as words.

The authors use the model’s working memory—a cache that stores information needed to continue the computation. It holds text, hidden steps, and tool responses. After searching or running a program, the agent continues with the same cache. There’s no need to convert the entire history back into text.

To train the system, the authors prepared 54,000 examples by converting existing agent action sequences into a mix of text and hidden segments. Steps that needed to be inspectable or used to call a tool remained in text. Others could be moved into hidden mode. Language-model judges and the model’s own confidence scores helped label the data.

HybridAgent was then fine-tuned in two stages. First, HybridSFT taught the model to switch between modes and work with HybridLink. There’s an important wrinkle: during standard training, the model sees the correct hidden steps, but at run time it has to continue from its own predictions. If those predictions differ even slightly from the training examples, errors can compound.

To narrow that gap, the authors used self-substitution training. The model first makes a trial pass, then on a second pass it receives its own hidden representations instead of the correct examples. This teaches it to work under conditions closer to actual use.

In the second stage, HybridRL, the agent learns through reinforcement. It earns rewards for correct answers, following the required format, and using tools effectively. It gets no reward for choosing hidden or text mode: it learns on its own when each is appropriate.

Test Results

The authors evaluated three model sizes—4, 8, and 14 billion parameters—on 11 benchmarks. The tasks included math competitions, science and medical questions, searches across multiple sources, and tool use.

On search tasks, the 14-billion-parameter HybridAgent outperformed the strongest comparable agent method by an average of 17.4%. It also beat text-based and hidden-reasoning methods trained on similar data in math and knowledge-based question answering. After reinforcement learning, accuracy on MATH500 reached 84.6% for the 8-billion-parameter model and 88.2% for the 14-billion-parameter model.

The efficiency results depend on what’s being measured. In an overall comparison, the authors report 35.5–54.7% fewer text tokens and inference speeds 1.8–2.6 times higher. In a separate comparison with text-based agents, the system used about 2.7 times fewer text tokens and cut the number of generation steps by up to 54%. An estimate of generation compute costs showed savings of 2.7–3.7 times. These estimates use GPU prices set by the authors and exclude input-context preparation and the operation of external tools.

HybridAgent uses fewer text tokens and generation steps than text-based agents.

The authors also try to make hidden reasoning inspectable. Each hidden step can be approximated by finding the closest word in the model’s vocabulary by meaning. The result is pseudotext: it may not read like a fluent sentence, but it can show whether the internal steps are related to the task. According to the authors, these representations become easier to interpret after training and better aligned with the original question.

Tests showed that hidden steps contribute to the solution. Replacing them with random representations or steps from another task significantly reduced accuracy on MATH500. For example, replacing hidden steps with segments from a different question lowered accuracy by about 45–47%. This suggests that both the content and order of the hidden representations affect the answer.

The visible text is still enough to check the solution process. Compared with a text-based agent, HybridAgent produced 43–49% fewer text tokens, while preserving more key steps per 100 tokens in the visible segments. In most cases, evaluator models could identify the first error and suggest a useful correction. But these results come from tests on selected tasks; they don’t prove that hidden reasoning can always be reliably checked.

Hidden steps can be approximated as pseudotext and compared with nearby explanations and tool calls.

Conclusion

HybridAgent shows how to build an agent that doesn’t have to narrate every step to interact with the outside world. It can use hidden representations for internal computation while reserving text for tool calls, important decisions, and its final answer.

This approach makes both training and the system itself more complex. It requires a new module, a specialized fine-tuning procedure, and software to preserve shared memory as the agent moves between hidden mode, text, and tool responses. Pseudotext offers only an approximate view of hidden representations and can’t guarantee that a person will see the exact reason behind every decision.

The results were tested on Qwen3 models and specific tasks, using fixed settings and tools. It remains unclear how easily the approach can be adapted to other models and real-world, long-running workflows.

An agent’s reasoning can be partly removed from the text stream while text remains available for actions and review. This could reduce generation costs and improve accuracy. For reliable use, it’s important to understand what remains visible to people—and how well hidden steps continue to guide the agent’s answers.

As the number of attempts increases, HybridAgent continues to improve on difficult math and science tasks.