DeReAct: Decoupling Reasoning and Acting for More Reliable AI Agents

The Structural Flaws of ReAct Agents

Most mainstream AI agents today are built on the ReAct paradigm. These systems rely on a single large language model policy to simultaneously handle three responsibilities: proposing the next action, interacting with the environment, and determining when a task is complete. Behind this seemingly efficient design lies a structural problem — coupling all responsibilities into a single policy makes it difficult to independently enforce action authorization and completion control.

This coupling introduces two typical risks. First, errors propagate along the reasoning chain, where a misjudgment in one step contaminates all subsequent decisions. Second, the model may prematurely terminate task execution based on unsupported "completion claims" — in other words, the agent believes it has finished when the problem hasn't actually been solved. For task scenarios requiring high reliability, this kind of unchecked self-judgment is fatal.

ReAct (Reasoning + Acting) is an agent paradigm proposed by Google Research in 2022. Its core idea is to have large language models alternately generate "Thought" and "Action" steps when executing tasks, incorporating environmental observations (Observation) into subsequent reasoning. This "Think-Act-Observe" loop gives models a degree of planning and self-correction capability, and serves as the underlying logic for mainstream frameworks like AutoGPT, LangChain Agent, and OpenAI Function Calling. However, ReAct was designed more with "making models capable" in mind than "ensuring models are reliable." In an architecture where a single model simultaneously plays planner, executor, and validator, there is no independent verification mechanism between the model's confidence and actual task completion quality — a problem that surfaces quickly when tool calls fail, context windows grow too long, or task chains become complex.

DeReAct's Modular Approach to Breaking the Deadlock

To address these pain points, this research proposes DeReAct — a modular agent architecture whose core idea is to externalize two critical "gating policies" from the main model into independent control components.

The first component is the Critic. Its responsibility is to validate actions before they are actually executed, functioning as a gate for action authorization. Only actions that pass review are permitted to affect the environment, thereby blocking the propagation of erroneous actions.

The second component is the Context Manager. It is responsible for reconstructing an environment-backed State and certifying task completion. In other words, whether a task is truly complete is no longer left to the main model's self-declaration, but instead adjudicated by an independent module backed by environmental evidence. This directly addresses the problem of "unsupported completion claims."

The essence of this design is responsibility decoupling: separating "making decisions" from "reviewing decisions," and separating "doing the work" from "validating the work." Reasoning and Acting are decomposed into different policies — which is exactly where the name DeReAct (Decomposed ReAct) comes from.

Experimental Results: Weaker Models Benefit Most

The research team evaluated DeReAct on two benchmarks — GAIA and SWE-bench Verified — and the results reveal a clear and intriguing pattern: external gating provides the greatest improvement for less capable main models (Brain Models), with gains gradually diminishing as the main model's capability increases.

In concrete numbers:

• For Qwen3-Coder-480B, Pass@1 improved by 6.5 to 7.0 percentage points;
• For Claude Sonnet 4.5, the improvement was 4.2 to 5.2 percentage points;
• For the more capable Claude Opus 4.5, Pass@1 was roughly on par with the original ReAct baseline.

The logic behind this trend is not hard to understand. Trajectory analysis and ablation experiments show that for external gating to be effective, two preconditions must be met: first, the target type of failure must be sufficiently common in the original trajectory (i.e., there are actually errors to correct), and second, the gating policy itself must be strong enough (i.e., the corrector must be more reliable than the one being corrected). Weaker models make more mistakes, so the Critic and Context Manager can intercept more errors; stronger models make fewer mistakes to begin with, so the marginal value of external gating naturally decreases.

GAIA (General AI Assistants) is a benchmark designed to evaluate general-purpose AI agents, requiring agents to answer real-world questions by combining multiple tools such as web search, file processing, and code execution. Its core metric is Pass@1 (the proportion of tasks solved correctly on the first attempt). SWE-bench Verified focuses on software engineering scenarios, requiring agents to automatically generate and verify code patches based on real GitHub Issues — one of the authoritative benchmarks for measuring code agent capability. The "Verified" subset has been manually curated to ensure each problem has a clearly verifiable answer. Together, the two benchmarks cover both general task understanding and specialized code reasoning, forming a comprehensive stress test of agent reliability.

Completion Control: Trading Early Termination for Stronger Grounding

For strong models like Claude Opus 4.5, DeReAct doesn't raise the Pass@1 score, but it delivers value through a different channel — improved trajectory quality.

Experiments show that with DeReAct enabled, the trajectories produced by agents are more "evidence-complete" and constraint-satisfying. This means the completion control mechanism is actually making a tradeoff: sacrificing some efficiency from "earlier termination" in exchange for "stronger grounding." For tasks where result credibility matters more than speed, this tradeoff is clearly worthwhile.

From another angle, this reveals an important insight: for strong models, the reliability bottleneck may no longer be "can it get things right," but rather "is the process of getting things right traceable and verifiable." DeReAct provides exactly this kind of assurance.

Grounding in AI contexts refers to the correspondence between a model's output and real-world states or external evidence. A "well-grounded" conclusion means it is backed by a traceable evidence chain, rather than being generated purely from the model's internal parametric memory. In agent systems, grounding is especially critical — when an agent claims "task complete," it's often difficult to tell whether that claim is based on real environmental feedback or the model's inertial guess based on training distribution patterns. DeReAct's Context Manager, by requiring completion claims to be backed by environmental state evidence, essentially establishes an auditable evidence chain for every "wrap-up" decision the agent makes — particularly important for compliance requirements in high-stakes domains like finance, healthcare, and code deployment.

Implications for Agent Engineering

Overall, DeReAct achieves a desirable property: it improves weaker agents' performance while preserving grounding benefits even as model capability increases. In other words, this is an architectural choice that "sets a floor without imposing a ceiling."

From an engineering practice perspective, this research points to several directions worth emulating. The modular gating mechanism can serve as a general-purpose reliability enhancement layer, stacked on top of existing ReAct agents without needing to retrain the main model. At the same time, whether to introduce external gating should depend on the main model's capability and the failure patterns of the task — blindly adding gating to strong models may yield little return, but targeted gating for error-prone steps can be highly cost-effective.

As AI agents move from demos to production environments, "reliability" is replacing "capability" as the new central concern. Architectures like DeReAct that externalize and make control logic explicit represent one direction in the evolution of agent design from monolithic to modular.