DeepAgent replaces the agent pipeline with one long reasoning stream

LLM agents can reason, but reasoning is not enough to solve real tasks. An agent also has to call outside tools, work through long scenarios and stay autonomous across dozens of steps. Rigid pipelines with fixed modes get in the way of that, and so do the classic approaches like ReAct and Plan-and-Solve. They impose the same action loop every time and work well on tasks that take two or three steps. But hand the agent a broad set of APIs or MCP servers, let it go looking for new tools on its own, and give it a hard goal that takes 20–30 external tool calls, and the scaffolding starts hurting instead of helping. The agent loses autonomy, bloats its context and accumulates errors over long trajectories.

What the researchers propose

The paper's answer is not to break reasoning into stages but to run one continuous stream: while the agent is still thinking about which tool it needs, it searches for candidates with a retriever, reads the compressed descriptions of the APIs it turns up and calls them on the spot. For that it has two actions — a special call to the retriever and a single step for tools. The tool set is large to begin with and can grow through the retriever. All of it runs on one model and one reasoning track.

Memory that helps the agent act

Long trajectories sometimes work against the agent, whose attention drifts onto details that no longer matter. DeepAgent's answer is autonomous memory folding: on its own signal the agent inserts a fold step, and a helper model compresses the interaction history into three structured blocks — working memory (which subgoal is being solved right now and what has gotten in the way), episodic memory (what has already happened and which decisions were taken) and tool memory (which APIs were called, with what parameters and what came back). The memory is kept in a compact structure, so folding does not cost the agent the important facts about the task.

How it was trained

Ordinary reinforcement learning (RL) on agentic scenarios is often unstable: external tools respond in different ways, and their failures hit training hard. The paper proposes end-to-end RL with two additions. First, an LLM-based API simulator that mimics the responses of real services, which makes training over thousands of calls faster and cheaper. Second, training scenarios in which the tool call itself earns reward. The final advantage attribution function combines the reward for solving the task, the reward for tool calls and the reward for memory folding — and the task-level reward is assigned to the tokens responsible for the API call. That makes the learning signal far more targeted. The authors call the method ToolPO.

What the experiments show

The authors test DeepAgent in two regimes: one where every tool is already available, and one where the right tools first have to be found in a large database. Both use the ToolBench, API-Bank, TMDB, Spotify and ToolHop benchmarks. The new agent beats the alternative tool-use scenarios on all of them, and its margin is widest in open tool-retrieval mode. On the hard ToolBench split, DeepAgent-32B-RL reaches 64% success against the best pipelines at around 54%; on the hardest set, ToolHop, it gets 40.6% against 29–36% for the alternatives. The authors also test the agent on real tasks, with tool calling wired into ALFWorld, WebShop and GAIA — and there too the new approach comes out ahead. On GAIA, DeepAgent-32B-RL solves 53.3% of tasks against 42.5% for a strong hierarchical agent.

One detail matters: how these scenarios scale as the action limit rises. The authors try different limits on WebShop tasks. Under a tight action budget the agents are comparable, but the more calls the agent is allowed to make, the wider DeepAgent's lead over ReAct grows.

Why it matters

Real assistants need more than the ability to reason. They have to find their way around a rich set of APIs, change course when something fails and hold on to the goal across a long dialogue. DeepAgent's argument is that the way there is not to cut the process into artificial stages but to run a single reasoning stream with one unified tool-call action, extend the tool set through retrieval and manage memory so that important facts survive a long horizon. On top of that, models like this can be trained cheaply and stably thanks to API simulation and targeted RL with memory folding.

The limits: the agent still depends on the quality of tool retrieval. The simulator is useful during training, but it does not fully stand in for real external tools. Even so, moving to a single scenario instead of a set of built-in pipelines looks like a sensible next step for tool-using LLM agents.

DeepAgent is a step toward genuine "long thinking" in AI. It does not merely reason — it acts in a continuous stream, finds the tools it needs itself, manages its memory and learns directly from its own calls. The approach removes the artificial boundary between thinking and acting, turning an LLM from a conversational partner into an autonomous operator. That is the foundation for the next generation of assistants: the ones that finish tasks rather than answer nicely.

💾 Code