If ReAct was a spark, Pre-Act is a blueprint. In the paper Pre-Act: Multi-Step Planning and Reasoning Improves Acting in LLM Agents, Mrinal Rawat et al. challenge the single-step cognitive paradigm of ReAct, offering instead a roadmap for how agents should plan, reason, and act—especially when tool use and workflow coherence matter.

What Is ReAct? A Quick Primer

The ReAct framework—short for Reasoning and Acting—is a prompting strategy that allows an LLM to alternate between thinking and doing in a loop. Each iteration follows this pattern:

  • Thought: The model reasons about the current situation.
  • Action: It proposes a tool to invoke or a next move.
  • Observation: It receives feedback from the tool or environment.

While this loop gives LLMs basic interactive agency, it’s often myopic—reasoning is shallow, and there’s no notion of a global plan. ReAct also struggles with tools that require multiple steps or have complex dependencies.

Pre-Act: Reasoning as a Dynamic Plan

Pre-Act enhances this structure by producing an explicit multi-step plan up front. Each step is not only an action but is tied to a reasoned intention and revisited as new observations arrive. This approach resembles how a human would tackle a task: set the full agenda, then revise it adaptively.

The process involves:

  • Creating a plan S = {s1, s2, ..., sn, s_final}
  • Each si has thought_i, action_i, observation_i
  • Context is continually updated: Ct = {(a1,o1), ..., (ai,oi)}
  • Plans can be revised incrementally

🔍 Is Observation for Memory or Next Plan? Observation in Pre-Act serves both purposes. It updates the agent’s context (short-term working memory), which can then influence belief revision or trigger plan adaptation. In XAgent terms, we can treat observations as temporary buffers that pass signals to either confirm a belief or rewrite the next action plan.

Key Techniques Worth Porting to XAgent

Pre-Act isn’t just a better prompt format—it’s a cognitive scaffold. Here’s how XAgent can benefit:

1. Separation of Plan and Execution Memory

In Pre-Act, draft plans are constructed before execution begins. This prevents noisy or failed actions from corrupting long-term memory. For XAgent:

  • Use agent$memory$plan_draft to hold tentative steps.
  • Move actions to agent$memory$history only after validation.
  • Failed actions can be archived separately for retrospection.

This separation supports delayed commitment and rollback.

2. Intermediate Reasoning Slots per Step

Each step in Pre-Act includes a thought → action → observation micro-sequence. XAgent can mirror this by:

  • Allowing each pipeline function to emit a proposed reasoning trace (policy_thought)

  • Pairing it with intended_action

  • Adding a post-check function that takes observation and either:

    • Confirms and executes the update
    • Flags revision or prompts a new policy

This makes reasoning auditable and modifiable.

3. Two-Level Evaluation Framework

Pre-Act introduces robust evaluation at:

  • Turn-level: Was this action correct given the plan?
  • End-to-end: Did the entire plan lead to the goal?

In XAgent:

  • Score agent$pipeline[[i]] not just on execution, but alignment with belief.
  • Tag each agent episode with completion status and diagnostic markers (e.g., detour cost, replan count).

This encourages performance feedback not just on outcome, but on reasoning fidelity.

4. Curriculum-Based Fine-Tuning & Planning Templates

Pre-Act doesn’t overwhelm models by starting with full plans. Instead, it introduces simple ReAct-like examples first, then scales up. XAgent could:

  • Start agents with fixed pipeline scaffolds.
  • Gradually introduce flexibility via feedback (e.g., “This step didn’t work—propose an alternative”)
  • Use plan templates (YAML schemas) to guide low-capability agents

This minimizes fragility during bootstrapping.

5. Milestone Dependency Graphs for Orchestrator Layer

Pre-Act makes use of milestone graphs to represent task decomposition. For XAgent’s orchestrator:

  • Let user input be parsed into milestone_graph.yaml
  • Allow each agent to report status on assigned milestones
  • If milestone X depends on Y, trigger replanning if Y is not completed or fails

This formalizes task progression without hardcoding flows.

Final Thought: Cognition Needs Structure

Pre-Act doesn’t just outperform ReAct—it redefines how we should think about cognition in agents. It’s not about making bigger models act smarter; it’s about structuring intelligence so that even smaller models can act deliberately.

For XAgent, adopting Pre-Act’s layered planning, milestone graphs, and evaluation paradigms can move us closer to robust, interpretable AI workflows.

Cognaptus: Automate the Present, Incubate the Future