Reactive vs Deliberative Agents

Introduction

You've now built a reactive agent — the ReAct loop of L110–L111 (The Agent Loop → Building a ReAct Agent From Scratch) reacts to the latest observation and decides its next move one step at a time. That's one whole school of agent design. This lesson introduces the other school — deliberative agents that plan ahead — and, more importantly, teaches you when each one wins.

This isn't a new debate. It's the oldest question in agent design, and it long predates LLMs: should an agent react to the world as it is right now, or build a model of the world and reason about the future before acting? Robotics fought this war in the 1980s–90s; today it's playing out again as ReAct vs. plan-and-execute. Knowing the difference is what lets you pick the right architecture instead of defaulting to whatever a tutorial showed you.

In this lesson:

Reactive agents — sense → act, no plan (Brooks' subsumption; ReAct) — and where they shine and fail
Deliberative agents — sense → model → plan → act (sense-plan-act; Plan-and-Execute, ReWOO) — and their tradeoffs
The honest tradeoff: adaptivity vs. coherence, cost, and robustness
Hybrid agents (plan + re-plan) — what virtually every real production agent actually is — and when to use which

An infographic titled 'Reactive vs Deliberative Agents'. The oldest question in agent design, older than LLMs: react to the latest observation, or plan ahead from a model of the world? Three architectures shown as cards. REACTIVE (sense to act): Brooks' subsumption architecture (1986) and the AIMA simple-reflex agent couple perception straight to action — no world model, no lookahead; the LLM instance today is ReAct (think one step, act, observe, repeat). DELIBERATIVE (sense to model to PLAN to act): classic symbolic AI, sense-plan-act, the AIMA goal-based agent build a plan from a world model then execute it; LLM instances are Plan-and-Execute, ReWOO, LLMCompiler. HYBRID (plan above, react below, re-plan on surprise): layered architectures like 3T put a deliberative plan layer over a reactive execution layer; the LLM instance plans, executes reactively, and re-plans on surprise. A tradeoff table compares Reactive (ReAct) vs Deliberative (Plan-Execute) across: adapts to surprises (reactive immediately, deliberative only after detecting failure and re-planning), cost and latency (reactive higher — re-sends the growing transcript each step, about 35 percent more input tokens in one study; deliberative lower — plan once, about 2 LLM calls, ReWOO about 5x token efficiency), global coherence (reactive can wander or loop, deliberative has a coherent plan up front), robustness to a changing world (reactive high, deliberative brittle — a stale plan executes blindly), and inspect before running (reactive no, deliberative yes — the plan is auditable). When to use which: reactive for dynamic exploratory tasks; deliberative for complex multi-step tasks with known dependencies where cost matters; hybrid for hard long-horizon work in a changing world. Banner: pure reaction wanders, pure deliberation shatters on surprise — most real agents are hybrid, plan for coherence and re-plan for robustness, and you add planning only when it earns its cost.

Reactive Agents — React to Now

A reactive agent maps the current situation directly to an action. There's no internal model of the world and no lookahead — it senses, it acts, it senses again. Stimulus → response.

This has deep roots. In 1986 Rodney Brooks challenged the entire symbolic-AI orthodoxy with the subsumption architecture — behavior-based robotics built from layers of simple sense → act behaviors running in parallel, with higher layers subsuming (overriding) lower ones. His famous claim, "intelligence without representation": a robot doesn't need a symbolic world model to behave intelligently — the world is its own best model. In the Russell & Norvig (AIMA) taxonomy this is the simple reflex agent: pure condition–action rules (if <percept> then <action>).

Strengths: fast (no planning step), robust and real-time, and excellent in dynamic, unpredictable environments — because it's always responding to what's actually happening now, never to a stale plan.

Weaknesses: it's myopic. With no lookahead it can't natively handle goals that require a sequence planned in advance, it can get stuck in loops or local dead-ends, and its coherence over a long task is fragile.

The LLM instance you already know: ReAct. Think one step → act → observe → repeat. At each step it re-decides based on the latest observation — exactly a reactive agent, with the LLM as the (very smart) sense → act rule. That's why a bare ReAct loop can wander or re-try the same failing action: pure reaction has no plan to keep it on track.

Deliberative Agents — Plan, Then Act

A deliberative agent does the opposite: it maintains a model of the world, reasons about the future, and commits to an explicit plan before acting. Sense → model → plan → act.

These are the roots of classic symbolic AI — the sense-plan-act (SPA) paradigm that dominated robotics before Brooks, and the goal-based agent in AIMA: it doesn't just react, it has a target and uses search/planning to find a sequence of actions that reaches it.

Strengths: handles complex, multi-step tasks with dependencies, produces a globally coherent strategy, the plan is inspectable/auditable before you run it, and it can be cheaper — you plan once instead of re-reasoning every step.

Weaknesses: brittle. A plan is only as good as the world model it was built from; if the world changes or the model is wrong, the agent executes a stale plan blindly. Planning also adds latency up front, and it's a poor fit for highly dynamic environments.

The LLM instances: Plan-and-Execute, ReWOO, LLMCompiler. The basic shape — a planner writes the steps, an executor runs them (often with a cheaper model — plan with claude-opus-4-8/gpt-5.5, execute with claude-haiku-4-5/gpt-5.4-mini):

# DELIBERATIVE — Plan-and-Execute: plan ALL steps up front, then run them.
def plan_and_execute(task):
    plan = planner_llm(task)              # 1 strong-model call → an ordered list of steps
    #   e.g. ["search top restaurant open tonight", "book a table for 4 there"]
    results = []
    for step in plan:                     # execute each step (cheap model / direct tool call)
        out = execute(step)               # no expensive re-reasoning per step
        results.append(out)
        if failed(out):                   # the ONLY way it adapts: detect, then re-plan
            plan = replanner_llm(task, done=results, failure=out)
            return plan_and_execute_remaining(plan)
    return solver_llm(task, results)      # compose the final answer

# Fewer LLM calls than ReAct, an inspectable plan up front — but rigid:
# nothing reacts to a surprise UNTIL a step outright fails and triggers a re-plan.

ReWOO (Reasoning Without Observation) pushes deliberation to its limit — it plans with placeholder variables for tool results and never looks at an observation mid-run:

# ReWOO (Reasoning Without Observation) — deliberative taken to the extreme.
# PLANNER (1 call): writes the whole plan with PLACEHOLDERS for tool outputs —
# it reasons WITHOUT ever seeing a real observation:
#   Plan: search "top restaurant near office, open tonight"   ->  #E1
#         book a table for 4 at #E1                            ->  #E2
# WORKER: runs every tool, filling in #E1, #E2  (NO LLM in this loop)
# SOLVER (1 call): composes the final answer from the filled-in evidence.
#
#   → ~2 LLM calls total (vs ReAct's one-per-step) → ~5x token efficiency.
#   → BUT the plan is FROZEN: if #E1 comes back "fully booked", ReWOO has no
#     observation step to notice — it books nothing and fails. Max deliberation,
#     zero in-flight adaptivity.

ReWOO's ~2 LLM calls and ~5× token efficiency over ReAct are real wins — and its frozen plan is the clearest illustration of the deliberative weakness: no observation step means no in-flight adaptation. LLMCompiler is a cousin that plans a DAG of tasks and executes independent ones in parallel for speed. All of them trade adaptivity for coherence and cost.

The Tradeoff — Adaptivity vs. Coherence & Cost

Neither is "better." They sit at opposite ends of one spectrum, and the right choice depends entirely on how dynamic your task is and what you're optimizing for:

	⚡ Reactive (ReAct)	🧭 Deliberative (Plan-Execute)
Adapts to surprises	✅ immediately — re-decides each step	⚠️ only after it detects failure & re-plans
Cost / latency	⚠️ higher — re-sends the growing transcript each step (one comparison: ~35% more input tokens)	✅ lower — plan once (~2 calls; ReWOO ~5× token efficiency)
Global coherence	⚠️ can wander / loop on long-horizon tasks	✅ a coherent multi-step plan up front
Robustness to a changing world	✅ high — built for dynamic environments	⚠️ brittle — a stale plan executes blindly
Inspect before running	❌ no — improvised step by step	✅ yes — the plan is auditable
Best final results when…	the environment is dynamic (closed-loop adaptation wins)	the task is decomposable & stable (and you want it cheap)

The headline: reactive buys adaptivity and pays in tokens and coherence; deliberative buys coherence and low cost and pays in robustness. In practice, ReAct tends to get better final pass rates on dynamic tasks (it can course-correct), while plan-and-execute is cheaper and more predictable on stable, decomposable ones.

Watch Them Diverge

Theory becomes obvious when you watch it. Below, the same task — book a table at the top-rated restaurant that's open tonight — runs through a reactive, a deliberative, and a hybrid agent in lockstep. Toggle whether the world cooperates or throws a surprise (the top pick turns out to be fully booked), and step through. Keep an eye on each lane's LLM-call counter and final outcome:

One task, three minds. Toggle whether the world cooperates or throws a surprise (the top pick is fully booked), then step all three agents in lockstep. Watch the deliberative plan break, the reactive loop adapt at a higher LLM-call cost, and the hybrid re-plan and recover — the cost-vs-robustness tradeoff, made visible.

The whole tradeoff in one widget:

No surprise: all three succeed, and the deliberative plan is cheapest (fewest LLM calls — it doesn't re-think every step). A predictable task rewards planning.
Surprise: the deliberative agent follows its stale plan into a wall and fails (it had no step for "full"); the reactive agent adapts — but burns the most LLM calls re-deciding; the hybrid re-plans and recovers. A dynamic world rewards reacting and re-planning.

Hybrid Agents — Plan + Re-plan (what real agents do)

If reactive wanders and deliberative shatters, the obvious move is to combine them — and that's exactly where decades of robotics and modern LLM-agent practice converged. Layered/hybrid architectures (e.g. the classic 3T) put a deliberative planning layer on top of a reactive execution layer: plan at a high level for coherence, react at the step level for responsiveness, and re-plan when an observation invalidates the plan.

# HYBRID — plan for coherence, execute REACTIVELY, RE-PLAN when reality diverges.
def hybrid_agent(task, max_replans=3):
    plan = planner_llm(task)                     # deliberate: a coherent plan
    for _ in range(max_replans + 1):
        for step in plan:
            obs = execute(step)                  # react at the step level
            if invalidates_plan(obs):            # a surprise the plan didn't expect
                plan = replanner_llm(task, obs)  # deliberate again: recover
                break                            # restart with the fresh plan
        else:
            return done()                        # inner loop finished cleanly → success
    return "Re-planned too many times — escalate to a human."  # bounded, like every loop

# This is where most production agents live (e.g. LangGraph plan-and-execute with a
# re-plan node): a plan keeps it coherent; re-planning keeps it robust to surprises.

This is what virtually every serious production agent actually is — for example LangGraph's plan-and-execute template adds an explicit re-plan node, and Anthropic's orchestrator–workers pattern has a lead agent plan and delegate, then adjust. Two more named patterns sharpen the ends of the spectrum:

Reflexion — reactive + memory. After an attempt, the agent critiques its own output and retries with that critique in context (it lifted HumanEval coding pass rates from ~80% → ~91%). Reaction, plus a learning signal.
LLMCompiler — deliberative + parallelism. Plan a DAG, run independent steps concurrently for lower latency and cost.

The lesson of the hybrid: planning and reacting are not enemies — they're layers. A plan gives you a coherent thread to pull; re-planning keeps that thread honest when reality pushes back.

When to Use Which (and When NOT to)

Match the architecture to how dynamic the task is and what you're optimizing:

Reach for reactive (ReAct) when:

The task is dynamic / exploratory and conditions change as you go — debugging, customer support, web navigation, live troubleshooting.
The task is short (a handful of steps) — the per-step cost doesn't compound.
✗ Don't use pure reaction for long-horizon tasks needing global coherence, or when cost/latency is tightly constrained — it wanders and re-bills the growing transcript every step.

Reach for deliberative (plan-and-execute / ReWOO) when:

The task is complex and multi-step with known dependencies, decomposable up front.
You need an inspectable/auditable plan before execution (compliance, high-stakes actions), or you're cost-sensitive (fewer calls, cheaper executors, parallelism).
✗ Don't use rigid deliberation in highly dynamic environments where the plan goes stale fast — and never ship ReWOO-style frozen planning where an early result must change the plan.

Reach for hybrid (plan + re-plan) when: the task is hard, long-horizon, and the world can surprise you — which describes most real agentic work. Plan for coherence; re-plan for robustness.

And the meta-rule, straight from Anthropic's Building Effective Agents: add complexity only when it demonstrably improves outcomes. Deliberation, re-planning, and multi-agent orchestration are costs — reach for them when a simpler reactive loop measurably falls short, not by default. (Next lesson, L113 — Workflow vs Agent, takes this to its logical conclusion: do you even need an agent, or will a fixed workflow do?)

🧪 Try It Yourself

Reason through these — then check yourself with the widget:

Predict before toggling: with no surprise, which of the three agents uses the fewest LLM calls — and why? Now predict what happens to the deliberative agent when you turn the surprise on.
You're building an agent to triage a flaky production incident (logs change minute to minute, you don't know the steps in advance). Reactive, deliberative, or hybrid? Defend it in one sentence.
You're building an agent to generate a monthly compliance report (same 8 steps every time, must be reviewable before it runs). Which architecture — and which property of it matters most here?
A teammate ships a ReWOO agent for booking travel. The first leg sells out between planning and booking. What happens, and what's the minimal change that fixes it?

→ (1) The deliberative agent — it plans once and executes without re-reasoning each step, so on a cooperative world it's cheapest; turn on the surprise and it fails (its frozen plan has no step for "full"). (2) Reactive (ReAct) — a dynamic, unpredictable environment rewards adapting to each new observation over committing to a plan that's stale in seconds. (3) Deliberative (plan-and-execute) — stable, decomposable, repeated steps make planning cheap, and the killer property here is the inspectable/auditable plan before execution. (4) ReWOO's plan is frozen with no observation step, so it books the sold-out leg (or fails) without noticing — the minimal fix is to add re-planning (detect the failed booking and re-plan), i.e. make it a hybrid.

Mental-Model Corrections

"Deliberative (planning) agents are just more advanced/better than reactive ones." No — they're a different tradeoff, not an upgrade. Deliberation wins on stable, decomposable tasks; it's brittle exactly where reaction shines (dynamic worlds).
"ReAct is the only way to build an agent." ReAct is the reactive end of a spectrum. Plan-and-Execute, ReWOO, LLMCompiler are deliberative alternatives — and often cheaper.
"Planning ahead is always smarter." A plan is only as good as the world model behind it. In a changing world, a confident stale plan is worse than reacting — it executes blindly into reality.
"Reactive agents are cheap because they're simple." The opposite on cost: a reactive loop re-sends the growing transcript every step, so it often costs more tokens than planning once. Simple ≠ cheap here.
"This is an LLM-era invention." It's a decades-old robotics/AI debate — Brooks' subsumption vs. sense-plan-act, AIMA's reflex vs. goal-based agents. ReAct vs. plan-and-execute is the same split, re-run on LLMs.
"Pick one architecture and commit." Most real agents are hybrid — plan for coherence, re-plan for robustness. Layering beats purity.

Key Takeaways

The oldest split in agent design: reactive (sense → act, no plan — Brooks' subsumption; the AIMA simple-reflex agent; ReAct) vs. deliberative (sense → model → plan → act — sense-plan-act; the goal-based agent; Plan-and-Execute / ReWOO / LLMCompiler).
The tradeoff is adaptivity vs. coherence & cost. Reactive adapts to surprises instantly but re-bills the growing transcript and can wander; deliberative is coherent, inspectable, and cheap (ReWOO ~2 calls, ~5× tokens) but brittle to a changing world.
Reactive fits dynamic, exploratory, short tasks; deliberative fits complex, decomposable, stable, cost- or audit-sensitive tasks.
Real agents are hybrid: plan for coherence, execute reactively, re-plan when an observation breaks the plan (LangGraph plan-and-execute; orchestrator–workers). Reflexion adds self-critique; LLMCompiler adds parallelism.
Add deliberation/complexity only when it demonstrably improves outcomes — don't over-plan a simple task, don't pure-react a long-horizon one.
Next: Workflow vs. Agent — When Do You Actually Need One? — the most important cost decision, taking "add complexity only when it helps" to its conclusion.