ReWOO: plan-execute without observation

The default agent loop is ReAct: Thought → Action → Observation, repeat. It works, but it has a quiet cost. Every step feeds the entire growing transcript — every past thought, action, and tool result — back into the LLM to decide the next move. By step six the model is re-reading five steps of history on every call, and a noisy tool output can derail the whole chain.

ReWOO — Reasoning WithOut Observation — restructures this. Its bet: for many tasks you can write the whole plan up front, before seeing any results, then run the tools and answer in one shot. The reasoning never reads the raw observations, so the LLM is called a fixed small number of times instead of once per step.

Three roles: Planner, Worker, Solver

ReWOO splits the agent into three components, and only two of them call the LLM:

1. Planner (one LLM call). Reads the task and writes the complete plan as a list of steps, each a tool call. Because it doesn’t have earlier results yet, it refers to them with evidence variables — #E1, #E2, … — placeholders to be filled in later. For “What is the capital of the country that won the 2022 World Cup?”:

   Plan: Find the 2022 World Cup winner.        #E1 = Search["2022 World Cup winner"]
   Plan: Find that country's capital.           #E2 = Search["capital of #E1"]

2. Worker (no LLM). Executes each tool call in order, substituting the evidence variables as they’re resolved — runs #E1, plugs its result into #E2’s query, runs that, and so on. This is plain orchestration code, not a model call.

3. Solver (one LLM call). Receives the original task plus all the gathered evidence (#E1, #E2, …) and writes the final answer.

The plan is produced once; the tools run without the LLM; the answer is produced once. The model never re-reads a transcript that grows step by step.

Why it’s cheaper

Two things shrink. LLM calls: ReAct makes one per step (plus a final), ReWOO makes exactly two. And tokens per call: ReAct’s context grows every step as observations pile up, while ReWOO’s planner sees only the task and the solver sees the task plus a compact list of evidence. Put numbers on a six-step task:

base, step, N = 500, 300, 6
# ReAct: step i re-sends the base prompt + i steps of accumulated transcript
react = sum(base + i * step for i in range(1, N + 1))
# ReWOO: one planner call (base) + one solver call (base + all the evidence)
rewoo = base + (base + N * step)

print(f"ReAct LLM tokens (~{N} growing calls): {react}")
print(f"ReWOO LLM tokens (plan once + solve):  {rewoo}")
print(f"reduction: {react / rewoo:.1f}x")

ReAct LLM tokens (~6 growing calls): 9300
ReWOO LLM tokens (plan once + solve):  2800
reduction: 3.3x

The savings grow with the number of steps, because ReAct’s cost is quadratic-ish (each new step re-reads all prior ones) while ReWOO’s is roughly flat. The original ReWOO paper reported around 5× fewer tokens on multi-step benchmarks at comparable or better accuracy — the model isn’t distracted by re-reading raw tool dumps.

The trade-off: no looking back

ReWOO buys efficiency by giving something up: the plan is fixed before any result is seen. If #E1 returns something unexpected — an ambiguous entity, an error, an empty result — the rigid plan can’t notice and re-route. ReAct can: it sees each observation and decides the next step in light of it.

In one breath

• ReAct interleaves Thought → Action → Observation and re-sends the growing transcript to the LLM every step — many calls, ballooning tokens, easy to derail.
• ReWOO (Reasoning WithOut Observation) decouples them into Planner (one LLM call: full plan with #E1, #E2 evidence variables), Worker (no LLM: runs the tools, fills the variables), and Solver (one LLM call: evidence → answer).
• The model is called a fixed ~2 times and never reads raw observations, cutting tokens several-fold (3.3× in the demo, ~5× in the paper) at similar or better accuracy.
• The cost is no adaptivity: the plan is fixed before any result is seen, so it can’t re-route on a surprising or failed step.
• Use ReWOO for cleanly decomposable tasks; use ReAct/Reflexion for exploratory ones — and blend them in practice.

Quick check

Next

ReWOO commits to one plan; Tree of Thoughts goes the other way — exploring many reasoning branches with search and backtracking. For the loop that learns from its own failures between attempts, see Reflection.