ReAct (reasoning + acting) framework: Question bank

Before the questions, one shared vocabulary anchor so no symbol below is used unearned.

Definition Every symbol used on this page

$Q$ — the question the user asked (the input the whole trajectory is trying to answer). Read $P (τ ∣ Q)$ as "the probability of this trajectory given that the question was $Q$ ."
$τ$ (tau) — the full trajectory: the ordered list $[(Thought_{1}, a_{1}, o_{1}), (Thought_{2}, a_{2}, o_{2}), \dots]$ .
$a_{t}$ — the action chosen at step $t$ ; $o_{t}$ — the observation returned at step $t$ .
$τ_{< t}$ — the sub-trajectory before step $t$ , i.e. everything that already happened in steps $1$ through $t - 1$ . It is the model's "memory so far" when it decides step $t$ .
$T$ — the final time step: the step where the model emits $a_{T} = Finish [\cdot]$ . In practice $T$ is also capped by a step budget (a maximum number of loops), so a stuck agent is forced to stop.
$T$ — the set of available tools the agent may call (careful: different from the number $T$ ).

The picture and the correct formula both live below, so the trap questions have something concrete to point at.

Figure — ReAct (reasoning + acting) framework

The diagram above is the loop: a Thought feeds an Action, the Action hits the environment which returns an Observation, and that Observation feeds the next Thought — until Finish breaks the cycle.

True or false — justify

ReAct and chain-of-thought are the same thing because both produce reasoning text.

False. Chain-of-thought (a prompting style where the model reasons in steps but takes no external actions) only reasons; ReAct interleaves that reasoning with real actions and feeds the resulting observations back in. The observation channel is what CoT lacks.

An observation

o_{t}

is generated by the language model.

False. The observation comes from the environment (the tool). If the model could write its own observations, they'd carry no grounding — it could just hallucinate them.

If a task's answer is fully contained in the question

Q

(and its prompt), ReAct is strictly better than plain CoT.

False. With no external knowledge needed, actions add latency and failure points for no gain. ReAct's advantage only appears when the model must fetch something

Q

does not already supply.

The Finish step is just another action in the tool set

T

True.

a_{T} = Finish [answer]

is selected like any action, but its "execution" is termination — it ends the loop and emits the final answer instead of returning an observation.

Thoughts are optional decoration and could be removed without changing behavior.

False. Thoughts are what let the model recover from a bad observation and replan mid-trajectory; strip them out and you get a brittle action-only agent (an agent that fires tool calls with no reasoning between them — see the "Spot the error" ordering trap).

The trajectory probability

P (τ ∣ Q)

multiplies a term for the observation, so the model influences observations.

False. The observation term

P (o_{t} ∣ a_{t})

depends only on the action and the tool, not on the model's parameters. It is in the product for completeness, not because the model steers it (and in reality it may even be stochastic, per the idealization warning above).

ReAct guarantees a correct answer because observations are real.

False. Real observations reduce hallucination but don't remove it — the model can still misread an observation, search the wrong query, or stop too early. Grounding improves reliability, it doesn't promise correctness.

Two searches in a row (no thought between them) is valid ReAct.

Technically the format allows it, but it's an anti-pattern: without an intervening thought the second search can't adapt to what the first returned, killing error recovery.

Spot the error

A student writes: "ReAct's loop is Action → Thought → Observation." What's wrong?

The order is broken. Reasoning comes first (Thought), then the action it justifies, then the environment's Observation. Acting before thinking is the "act without reasoning" failure — you lose the ability to justify or adapt the action.

An agent does: Search["Eiffel Tower country"] → Observation: France → Finish["France"] for the question "capital of the country with the Eiffel Tower." What error occurred?

It answered the wrong question — it stopped at the country, not its capital. A missing second hop (Search["capital of France"]) means it skipped a required reasoning step; a Thought would have caught that the goal wasn't yet met.

Someone writes

P (τ ∣ Q) = \sum_{t} P (Thought_{t}) P (a_{t}) P (o_{t})

. What's wrong?

Two errors: it should be a product over steps (the steps must all happen, an "and"), not a sum, and every term must be conditioned on the prior history

τ_{< t}

— the steps are dependent, so unconditional factors model a memoryless agent that doesn't exist here.

An agent gets Observation: no results found and immediately emits Finish["I don't know"]. Where did it fail?

It skipped the reasoning step that should follow a bad observation. A proper Thought would reformulate the query or try a different tool — giving up on the first failed action wastes ReAct's whole error-recovery ability.

A prompt defines the tool set as

T = {t_{1}, t_{2}}

but the agent emits Action: Translate[...] which isn't in

T

. What's the conceptual bug?

Action selection ranges over the available tools

T

. Choosing a tool outside the set means the executor has nothing to run — the observation step cannot produce grounding.

Why questions

Why must a thought precede each action rather than following it?

Because the thought's job is to decide the next action from the current state; a thought after the fact can only rationalize, not steer. Reasoning first is what makes the action purposeful.

Why does interleaving beat "reason fully, then act at the end"?

Because reasoning done before any observation is built on incomplete information. Each observation can overturn earlier assumptions, so you want to think just enough to pick the next action, then re-think with fresh data.

Why is transparency listed as a benefit of ReAct?

The explicit Thought traces expose why each action was taken, so a human can audit the decision path — unlike an action-only agent whose choices are opaque.

Why can't pure chain-of-thought handle "the population of Paris in 2023"?

That fact may lie outside the model's frozen training data or be stale. CoT can only reason over what it already knows; without an action to fetch current data it may confidently hallucinate a number.

Why is ReAct described as a sequential decision process rather than one-shot generation?

Each step conditions on the entire prior sub-trajectory

τ_{< t}

, so the model makes a chain of dependent decisions — like a search through action space — not a single independent output.

Why does grounding specifically attack the "hallucinate-then-act" failure of action-only agents?

A real observation contradicts a wrong internal belief on the next turn, giving the reasoning a chance to correct course — the model literally sees evidence it was wrong before committing.

Edge cases

What happens if the very first observation already contains the full answer?

The loop can terminate after one action: Thought → Action → Observation → Finish, so

T = 1

. ReAct doesn't force extra hops; the terminating thought recognizes the task is complete.

What if a tool returns an empty or malformed observation?

This is a degenerate observation, not a dead end. The next thought should treat "empty" as information — reformulate the query, switch tools, or note the fact is unavailable — rather than crash or hallucinate a filler.

What if the model never emits Finish and keeps looping?

Then

a_{T} = Finish [\cdot]

is never triggered, so the step budget (the cap on

T

) cuts it off. Conceptually this is a planning failure — thoughts aren't converging toward completion.

Is a trajectory with zero actions (thoughts only, then Finish) still ReAct?

Degenerately it collapses to plain chain-of-thought. It's valid syntax, but if no external knowledge was needed the "ReAct" label adds nothing over CoT for that instance.

If two different tools in

T

could answer the same sub-question, does ReAct specify which to pick?

Not deterministically — the action-selection term

P (a_{t} ∣ Q, τ_{< t}, Thought_{t})

is the model's own distribution, so the choice depends on the few-shot examples and phrasing, not on a hard rule. Different prompts can send the agent down different valid tool paths.

What distinguishes ReAct's error recovery from Reflexion's?

ReAct corrects within a single trajectory using observations as they arrive. Reflexion adds an outer loop: after a full attempt it writes a verbal self-critique and retries the whole task, learning across trajectories rather than only within one.

How does ReAct relate to plain Tool Use in LLMs?

Tool use is just the action half — the ability to call an external function. ReAct wraps tool use in explicit reasoning and observation feedback, so it's tool use plus a think-and-adapt control loop.

Recall Fastest self-check

Order the loop from memory. ::: Thought → Action → Observation, repeated until Finish[...]. Who writes the observation? ::: The environment / tool, never the model. What does $τ_{< t}$ mean? ::: All steps before step $t$ — the agent's memory when it decides step $t$ . Why is $P (τ ∣ Q)$ a product? ::: A trajectory needs every step to happen (an "and"), and "and" over probabilities multiplies. One thing grounding does NOT guarantee. ::: A correct answer — it only reduces, not eliminates, hallucination.