RP-ReAct: Hybrid Reasoning & Reactive Execution

• The paper introduces RP-ReAct, a hybrid agent architecture that decouples high-level reasoning/planning from low-level reactive execution, enhancing interpretability and scalability.
• Its design leverages separate Reasoner–Planner and ReAct modules to efficiently manage goal selection and tool invocation in diverse domains such as simulation, logic reasoning, and enterprise tasks.
• Empirical evaluations demonstrate that RP-ReAct improves task performance by reducing inference FLOPs and enhancing accuracy in multi-step, tool-augmented workflows.

RP-ReAct (Reasoner Planner–ReAct) designates a class of hybrid agent architectures that integrate a dedicated reasoning/planning component (“Reasoner–Planner”) with a reactive execution or tool-call loop (“ReAct”), typically mediated through explicit intra-agent interfaces. RP-ReAct unifies symbolic, neural, and tool-augmented paradigms by separating high-level cognitive control (goal selection, planning, reasoning) from low-level execution (action, observation, tool invocation), leading to improved interpretability, controllability, and tractable scalability across diverse application settings (Puerta-Merino et al., 17 Jan 2025, Molinari et al., 3 Dec 2025, Wei et al., 13 Nov 2025, Lyu et al., 2022, Saribatur et al., 2016, Liu et al., 9 Oct 2025, Patra et al., 2020).

1. Fundamental Architecture and Principles

RP-ReAct instantiates a systemic decoupling between “Reasoner–Planner” modules that decide what to do, and “ReAct” or executor modules that determine how to do it. This design is applicable in simulation, enterprise, code generation, multi-agent, and logic reasoning settings, but is unified by several core constructs:

• Reasoner–Planner: Performs high-level task decomposition, goal selection, contextual interpretation, or structured planning. This module may be implemented as a classical symbolic planner (Puerta-Merino et al., 17 Jan 2025, Saribatur et al., 2016), a neural logic operator stack (Lyu et al., 2022), a PDDL or operational model planner (Patra et al., 2020), or a LLM operating as a planning agent (Molinari et al., 3 Dec 2025, Wei et al., 13 Nov 2025, Liu et al., 9 Oct 2025).
• ReAct Executor: Operates an interleaved “Thought → Action → Observation” loop. This module invokes tools, executes action sequences, runs code, or interacts with the environment, accepting sub-goals or execution steps from the planner (Molinari et al., 3 Dec 2025, Liu et al., 9 Oct 2025, Puerta-Merino et al., 17 Jan 2025).
• Interface: Synchronizes memories, world state, and communication between the planning and execution layers, ensuring correct mapping and transfer of goals, results, perceptions, or tool outputs (Puerta-Merino et al., 17 Jan 2025, Molinari et al., 3 Dec 2025).

The following table compares the principal roles found in RP-ReAct architectures:

Module	Primary Function	Typical Implementation
Reasoner–Planner	Goal/plan selection, strategy	LLM, symbolic planner, RL meta-policy
ReAct Executor	Reactive execution	ReAct loop (LLM or agent), tool APIs
Interface	State management, mapping	Mapping functions, external memory

2. Formal Frameworks and Algorithmic Structure

A common thread in all RP-ReAct instantiations is the formal decoupling of “target selection” (Reasoner–Planner) and “plan execution” (ReAct), with rigorous abstractions enabling correct-by-design policies and efficient implementation (Saribatur et al., 2016, Lyu et al., 2022, Puerta-Merino et al., 17 Jan 2025):

• Transition System: RP-ReAct is often formalized as a two-level transition system. A high-level abstract state space captures relevant context for the Reasoner–Planner (e.g., clustered states or logical abstractions), while the executor operates over concrete world or tool states (Saribatur et al., 2016).
• Sequential Workflow: The canonical RP-ReAct loop proceeds as: (1) perceive/abstract world state; (2) Reasoner–Planner selects or updates goals/plan; (3) an executor instantiates and carries out the plan, reporting observations or feedback; (4) upon plan completion or new perceptions, repeat (Puerta-Merino et al., 17 Jan 2025, Molinari et al., 3 Dec 2025).
• Multi-agent Realization: In enterprise/task-execution settings, the Reasoner–Planner acts as a supervising agent issuing sub-questions or plans, each of which is processed/reacted to by downstream executor agent(s) via a ReAct loop (Molinari et al., 3 Dec 2025).
• Planning and Reasoning Paradigms: The Reasoner–Planner is variably instantiated: as classical AP (Automated Planning), MCTS-based neural policies (Lyu et al., 2022, Patra et al., 2020), global DAG planners (Wei et al., 13 Nov 2025), or hierarchical task decomposition modules (Liu et al., 9 Oct 2025).

Example: The RP-ReAct update procedure in “LLM Reasoner and Automated Planner” iterates as:

1. Perceive environment and generate candidate goals (Interface).
2. Select goal using LLM Reasoner.
3. Produce a symbolic action plan via an AP planner.
4. Execute next plan step and observe effects (Interface/ReAct) (Puerta-Merino et al., 17 Jan 2025).

3. Variants and Domain-specific Instantiations

RP-ReAct exists in several domain-tailored forms, which demonstrate the generality and specialization potential of the paradigm:

• NPC Simulation (LLM Reasoner + Classical Planner): Reasoner maintains personality- and history-informed memory, proposing plausible, context-sensitive goals via LLM; Planner guarantees sound executable plans for chosen goals; Interface mediates memory and world updates. Plausible but sometimes suboptimal behaviors with personality-induced modulation are observed (Puerta-Merino et al., 17 Jan 2025).
• Multi-task Logic Reasoning (PRIMA): Neural Reasoner exposes transferable FOL operators; dynamic Planner chains operator subsets into proof paths via RL-guided MCTS, yielding both generalization and inference efficiency (Lyu et al., 2022).
• Enterprise Task Execution (Multi-agent ReAct): Reasoner–Planner agent decomposes tasks into sub-questions, issued to a Proxy-Execution agent running ReAct over tool APIs; robust performance across model sizes and task complexity is facilitated by context-saving strategies and division of cognitive labor (Molinari et al., 3 Dec 2025).
• Planner-Centric Complex Tool Augmentation: The Planner outputs a global workflow DAG for multi-tool queries; the executor implements a ReAct loop per node, achieving high parallelism and avoiding local minima (Wei et al., 13 Nov 2025).
• Code Generation and Safety Use-Case: Planner decomposes code editing tasks; Searcher (ReAct-based Reasoner) alternates reasoning traces and tool calls for secure and controllable generation, with explicit logs and safety constraints (Liu et al., 9 Oct 2025).
• Hierarchical Operational Models: Reactive Acting Engine (RAE) topped by anytime UCT-style MCTS operational planner (UPOM), with learned heuristics enabling robust online deliberation under uncertainty (Patra et al., 2020).

4. Theoretical Properties and Correctness

RP-ReAct’s separation of concerns admits rigorous analysis and formal guarantees in certain formulations (Saribatur et al., 2016, Patra et al., 2020, Lyu et al., 2022):

• Decidability and Correctness: Policy correctness—the guarantee that every feasible trajectory achieves the main goal in finite time—is PSPACE-complete to check in the abstract space. Outsourced Planner soundness is in $\Pi_3^p$; completeness is in $\Pi_4^p$ (Saribatur et al., 2016).
• Convergence: In MCTS-based settings, as in UPOM or RL-trained Planner-Reasoner agents, UCT-style exploration guarantees asymptotic selection of optimal policies/methods under monotonicity and static-world conditions (Patra et al., 2020, Lyu et al., 2022).
• Sampling and Abstraction: Proper state clustering and abstraction can reduce the abstract state space dramatically, supporting tractable policy and planning synthesis (Saribatur et al., 2016).

5. Tool Integration, Context Management, and Efficiency

RP-ReAct architectures often target environments where tool invocation, context-window size, or execution traceability are critical:

• Toolcalling and ReAct: Executors use the ReAct framework to reason and act interleavedly: Thought-states elicit an Action (tool/API call), which yields an Observation fed back into the system. This loop supports integration with databases, code interpreters, search APIs, and more (Molinari et al., 3 Dec 2025, Wei et al., 13 Nov 2025, Liu et al., 9 Oct 2025).
• Context-saving Mechanisms: Executor agents employ context-window management—offloading large outputs from tool calls (e.g., database queries) to external memory, feeding only short previews back to the planner to avoid context overflow (Molinari et al., 3 Dec 2025).
• Inference Efficiency: End-to-end inference steps are reduced in RP-ReAct as compared to monolithic ReAct; the planner generates global or batch plans, allowing the executor to operate with fewer high-level LLM invocations and greater computation efficiency (Wei et al., 13 Nov 2025, Lyu et al., 2022, Patra et al., 2020).

6. Empirical Results and Comparative Evaluations

Across instantiations, RP-ReAct exhibits improved robustness, generalization, and end-to-end task performance, especially for multi-step or complex tasks:

• Simulation: NPC agents in the FireFighter benchmark showed context-sensitive, plausibly human behavior—first saving trapped individuals, then extinguishing fires—with iteration times of ≈1s due to LLM call latency; multi-agent coordination remains an open challenge (Puerta-Merino et al., 17 Jan 2025).
• Logic Reasoning: PRIMA’s RP-ReAct achieved 100% accuracy on multi-task logic problems, reducing inference FLOPs by 5–20× over monolithic neural logic provers (Lyu et al., 2022).
• Enterprise QA (ToolQA Benchmark): RP-ReAct outperformed monolithic ReAct and Reflexion baselines by 5–15 accuracy points on hard tasks (≥6 sub-steps), reduced accuracy variance by up to 50%, and achieved state-of-the-art combined performance scores (CPS) on 4/5 domains (Molinari et al., 3 Dec 2025).
• Complex Tool Planning (ComplexTool-Plan, StableToolBench): DAG-planner RP-ReAct achieved node F1 ≈ 0.98 and SoPR up to 59.8% on hard tool-augmented reasoning tasks, surpassing GPT-4o and open-source LLMs even when using smaller models (Wei et al., 13 Nov 2025).
• Code Generation (SVEN / CodeQL): RA-Gen’s RP-ReAct achieved a 94.8% security rate, outperforming GPT-4, with empirical ablations demonstrating critical dependence on both the Planner and ReAct-based Searcher (Liu et al., 9 Oct 2025).
• Operational Model Planning: Planning with 5 rollouts increased “Efficiency” by >30% over purely reactive acting, and success ratio by up to 25% in nondeterministic simulation domains (Patra et al., 2020).

7. Limitations, Open Questions, and Future Directions

Despite its demonstrated strengths, RP-ReAct faces several design and research challenges:

• LLM Unpredictability: LLM-based Reasoners may hallucinate or violate personality prompts, impacting the reliability of high-level decision-making (Puerta-Merino et al., 17 Jan 2025).
• Scalability and Coordination: Multi-agent RP-ReAct instantiations are prone to goal duplication or task interference unless explicit coordination or additional reasoning layers are provided (Puerta-Merino et al., 17 Jan 2025, Molinari et al., 3 Dec 2025).
• Context-Window Constraints: Tool outputs exceeding LLM context windows necessitate sophisticated memory management to preserve information and result consistency (Molinari et al., 3 Dec 2025).
• Prompt Compliance and Model Tuning: Full prompt adherence remains challenging in open-weight models; ongoing work explores larger LLMs, fine-tuning, and hybrid symbolic/LLM approaches (Puerta-Merino et al., 17 Jan 2025, Lyu et al., 2022).
• Generalization and Domain Adaptation: The ability of RP-ReAct to generalize to unanticipated domains, tools, or tasks depends on the flexibility of Reasoner–Planner representations and the transferability of interpreter modules (Saribatur et al., 2016, Lyu et al., 2022, Liu et al., 9 Oct 2025).
• Formal Verification: Model checking, temporal goal specification, and formal reasoning about RP-ReAct policies constitute active areas for further development (Saribatur et al., 2016).

Planned future work includes hybridizing RP-ReAct with behavior trees, enhancing multi-agent coordination, automating symbolic domain generation, and extending planners to handle temporally extended or durative actions (Puerta-Merino et al., 17 Jan 2025, Molinari et al., 3 Dec 2025).

---

RP-ReAct represents a broad, modular family of agent architectures that combine high-level, explicit reasoning or planning with low-level, robust, tool-augmented execution. Its theoretical and practical properties enable tractable and controllable agent behaviors across simulation, logic, tool-using QA, and complex real-world workflows, while its limitations highlight critical challenges in interpretability, coordination, and efficient deployment (Puerta-Merino et al., 17 Jan 2025, Lyu et al., 2022, Molinari et al., 3 Dec 2025, Wei et al., 13 Nov 2025, Liu et al., 9 Oct 2025, Saribatur et al., 2016, Patra et al., 2020).