ReAct Executor: Modular Multi-Agent Execution

• ReAct Executor is a specialized agent that implements a ReAct-style loop to transform decomposed planner instructions into concrete tool calls.
• It employs modular components—input interface, decision module, and context manager—to manage context and optimize tool output handling.
• Its strict separation of planning from execution improves trajectory stability and overall performance in complex multi-agent systems.

A ReAct Executor is a specialized agent that implements the ReAct (Reason + Act) paradigm within multi-agent frameworks to automate tool-augmented, iterative reasoning and execution. In recent literature, the ReAct Executor is instantiated as a low-level agent responsible solely for transforming decomposed instructions—generated by a higher-level planner—into concrete sequences of tool calls, while systematically managing context and intermediate outputs. This approach departs from monolithic agent designs by enforcing a strict separation of strategic planning from execution, thereby improving trajectory stability, context efficiency, and controllability in complex, multi-step enterprise and code generation tasks (Molinari et al., 3 Dec 2025, Liu et al., 9 Oct 2025).

1. Definition and Role

The ReAct Executor is defined as a lightweight, process-driven agent within hierarchical agentic systems. Its primary function is to receive finely-scoped sub-step instructions from an upstream planner or reasoner, execute these steps via a ReAct-style loop—alternating between "Thought" (internal reasoning) and "Action" (tool invocation)—and return succinct results upon completion. Unlike standard ReAct agents, which combine global planning, tool selection, and context management in a single loop, the ReAct Executor is a strict executor: it does not engage in global goal reasoning, outcome re-planning, or high-level task allocation. This functional atomicity positions the ReAct Executor as a predictable, context-efficient executor of planner-driven instructions (Molinari et al., 3 Dec 2025).

In both RP-ReAct and RA-Gen frameworks, the ReAct Executor is instantiated as either the Proxy-Execution Agent (PEA) or the Searcher, respectively. These agents consistently implement the ReAct loop with rigorous tool invocation, dynamic context trimming, and structured result hand-off to upstream agents (Molinari et al., 3 Dec 2025, Liu et al., 9 Oct 2025).

2. Architectural Components and Data Flow

The ReAct Executor is composed of modular subcomponents designed for clear input/output semantics and robust execution flow. In the RP-ReAct architecture (Molinari et al., 3 Dec 2025):

• Input Interface: Accepts a single planner-generated sub-step, clearly delimited (e.g., <|begin_search_query|> ... <|end_search_query|>).
• ReAct Core Loop (Decision Module): Maintains an execution scratchpad with sequential (Thought, Action, Observation) tuples. At each loop iteration, it generates a Thought (plans the next tool call), Acts (invokes one of a fixed set of tool primitives), and Observes (records output).
• Context Manager / Offloader: If a tool output exceeds a hard token threshold $T$ (e.g., 100 tokens), only the prefix is retained in-context; the remainder is externally stored as a uniquely indexed variable. This enables future steps to reference large artifacts without context overload.
• Output Interface: Produces a result structure (e.g., <|begin_search_result|> ... <|end_search_result|>), which is returned to the planner agent.

The typical data flow for a single sub-step execution is:

From	To	Contents
Reasoner-Planner	ReAct Executor	Sub-step (delimited query)
ReAct Executor	Tool suite	Tool call with parameters (via Act)
Tool suite	ReAct Executor	Observation (raw tool output)
ReAct Executor	Reasoner-Planner	Packaged result (possibly variable ref)

This modular stratification ensures that responsibility for global context, error handling, and high-level trajectory remains with the planner (Molinari et al., 3 Dec 2025).

3. Core ReAct Loop Formalization

The central logic of the ReAct Executor is an iterative (Thought→Act→Observe) loop, expressible as a finite horizon Markov decision process. A typical pseudocode representation (Molinari et al., 3 Dec 2025, Liu et al., 9 Oct 2025):

$t$3

In RA-Gen, the “Searcher” alternates similarly: at step $t$, the state $s_t$ and history $h_{<t}$ inform a reasoning output $r_t = \mathrm{Reason}(s_t, h_{<t})$, followed by an action $$a_t = \mathrm{Act}(r_t, \mathcal{T}_\mathrm{external})$$, resulting in a state update $s_{t+1} = \mathrm{Update}(s_t, a_t)$. This loop persists until an explicit task completion signal or iteration limit (Liu et al., 9 Oct 2025).

4. Context Management and Output Handling

A distinctive advance of the ReAct Executor is its aggressive, algorithmic management of context window usage. In RP-ReAct, every Observation exceeding the threshold $T$ is truncated in-context, and the full output is offloaded:

$$\text{in\_context}_\text{obs} = \begin{cases} obs, & |obs|\le T \ \mathrm{prefix}_T(obs) + [v_k], & |obs|>T \end{cases}$$

with $v_k$ an external variable pointer. Future Thought or Action steps reference $t$0 on demand (e.g., PythonInterpreter[$t$1] [...]), avoiding context swelling from large tool or database outputs.

In RA-Gen, the ReAct Executor applies dynamic tool selection and integrates external outputs within a reasoning trace, maintaining clarity and auditability across consecutive steps. Explicit user-facing policies can regulate tool access, resource expenditure, and acceptance thresholds, directly impacting context usage and output fidelity (Liu et al., 9 Oct 2025).

5. Integration in Hierarchical Multi-Agent Systems

ReAct Executors are designed for structural subordination within hierarchical, multi-agent architectures:

• RP-ReAct: The Reasoner-Planner Agent (RPA) decomposes global tasks into atomic sub-steps. Each Proxy-Execution Agent (PEA) executes exactly one sub-step (via the ReAct loop) and returns atomicized results to the RPA. This decouples strategic reasoning from noisy, context-intensive execution, promoting stability and parallelism in complex scenarios (Molinari et al., 3 Dec 2025).
• RA-Gen: The Searcher receives subtasks from the Planner, executes ReAct-based reasoning/tool calls, and hands over results to the CodeGen agent. Codified feedback mechanisms and safety policies ensure that code generation is both controlled and verifiable, with every Searcher action traceable back through structured logs and user-editable configuration (Liu et al., 9 Oct 2025).

The intentional modularization precludes context bloat and reasoning drift: only high-value results ever propagate to the planner or downstream synthesizer.

6. Evaluation and Empirical Performance

Empirical results demonstrate marked gains in stability, generalization, and performance through the adoption of the ReAct Executor paradigm:

• In RP-ReAct, the context-saving strategy reduced average token injection by roughly 75% in SQL/CSV domains. The standard deviation of accuracy across models dropped by approximately 50%, and task completion rates increased by 10–20% on multi-hop, tool-using questions. The Combined Performance Score (CPS), defined as $t$2, increased over baseline monolithic approaches (Molinari et al., 3 Dec 2025).
• In RA-Gen, the ReAct-based Searcher achieved a CodeQL security fix rate of 94.8% on the SVEN dataset, outperforming GPT-4 (92.3%) and other leading models. Controlled ablations confirmed that removing the ReAct Searcher led to a 12 percentage point drop in security rate, while disabling safety policies or interactive approvals measurably reduced overall effectiveness (Liu et al., 9 Oct 2025).

These results underscore the ReAct Executor’s centrality to robust, interpretable, and efficient multi-agent execution in both enterprise and secure code generation domains.

7. Transparency, Control, and User Interaction

The ReAct Executor’s architecture enables granular observability and intervention. RA-Gen exposes user-facing YAML/JSON policies for permitted tools, confidence thresholds, and maximum iterations. Debug/verbose mode provides step-indexed visibility into every reasoning, action, and observation tuple; an intermediate trace inspector visualizes execution; interactive controls permit real-time approval, vetoing, and policy editing. These affordances ensure that the system remains auditable and steerable at every stage of complex tool-augmented reasoning (Liu et al., 9 Oct 2025).

This suggests that the adoption of ReAct Executors within hierarchical agents substantially advances practical reliability, transparency, and efficiency for demanding orchestration tasks involving large external knowledge bases and diverse tool suites.