ReAct

An observation is the tool's actual output, appended to the transcript by the runtime after an action. The model must never produce it: generation stops at the action, the real result is inserted, and only then does the model continue.

The runtime resolves the action name against its registered tool catalogue, deserializes the arguments and validates them against that tool's schema, then executes. Anything that fails resolution or validation never reaches the tool — an error is returned instead.

A short self-written note in plain language about why the attempt failed and what to do differently. That note is appended to the next attempt's context, so the retry starts from an explicit lesson instead of repeating the same action.

The model ends the loop by producing a final answer instead of an action. Because that signal is only the model's own judgement, the surrounding harness adds external stops it cannot override: a cap on passes, a cost or time limit, and a goal check on the result.

Writing a reason first forces the next action to be chosen from the current evidence rather than from habit. Without it the agent emits plausible-looking call sequences that ignore what the last result said, and nothing in the run catches the divergence.

Reduce by relevance, not by position. Extract the fields or rows the current step actually needs, and leave an explicit marker saying how much was dropped, so the model treats the observation as partial rather than complete.

A model that has seen Thought/Action/Observation exemplars will happily write the observation itself. Halting generation at the "Observation:" label hands control back to your runtime, which calls the real tool and appends the true result.

A well-formed ReAct thought states where the task stands against the goal, names the one piece of information still missing, and justifies the next action as the way to get it. Text that does not change which action follows is decoration.

Free-text action lines have no reliable grammar, so a quote or bracket inside an argument breaks the regex — often truncating the value silently rather than erroring. Structured tool calls constrain output to the declared schema, so arguments arrive already parsed and typed.

Render the empty case as explicit text, never as blank output. A literal such as NO_RESULT, plus the arguments used, tells the model the tool ran and matched nothing, which is a fact to reason about rather than a gap to fill from memory.

A thought is free text the model writes and then re-reads as if it were evidence. When it asserts something no observation supports — a policy limit, a field name, an id — later steps inherit that invention as established fact and act on it without ever checking.

Three different jobs with different failure modes: the actor produces the attempt, the evaluator judges it and returns a verdict or score, and the self-reflection step turns that thin verdict into concrete written advice the actor can act on next time.

A handful — typically two to six complete trajectories — is enough to teach the block grammar and the handoff rhythm. Add more only when a measured failure demands it, because exemplars sit in the prefix and are re-sent on every step of the loop.

Score every round against a signal outside the critic rather than trusting the critic's own satisfaction, keep the best-scoring version instead of the last one, and stop when the diffs become paraphrase-level churn or the critique starts repeating and contradicting itself.

Because each pass re-derives the next action from a context that barely changed. When an observation adds nothing usable, the state that produced the last action is effectively reproduced, so the same action is chosen again, and the loop has no built-in notion of progress to notice it.

Require the thought to quote a short span or cite the observation id before it draws a conclusion, and make sure your reduction preserved the line the conclusion depends on. Ungrounded thoughts drift into plausible paraphrase within two or three steps.

Rarely, as of mid-2026 — mainly with models that lack reliable structured tool calling, with action spaces that are not function-shaped, or when you need a provider-portable transcript you fully control. Otherwise the structured interface removes the exemplars, the stop string and the parser.

The stable, per-agent material: role and scope, the catalogue of available tools with when each applies, the required output format, escalation and refusal rules, and the operating limits. Per-request data — the customer's ticket, retrieved documents, tool results — belongs downstream, not here.

On long runs the original instruction sits far behind a wall of observations, and its influence on the next token weakens. Periodically re-writing the goal and what remains puts the objective back near the point of generation, which is the cheapest defence against drift.

Overlapping tool definitions are usually the cause: the model reads names and descriptions as prompt text and cannot tell which surface owns the question. Rewrite each description to state what it is for and when to prefer the other, and merge genuine near-duplicates.

Fan out only when the calls are independent reads whose arguments do not depend on each other's results. Keep writes sequential: parallel writes have no ordering guarantee, and a partial failure leaves inconsistent state with nothing to roll back.

Self-critique stops being evidence when the critic shares the actor's blind spot or caves under pushback. A verdict that flips to "looks correct" after one objection is measuring agreeableness, not correctness, so calibrate the critic against seeded known-bad outputs before trusting it.

Take loop control into a state machine when the run must be auditable, resumable, or constrained — regulated or irreversible operations, long-running work that must survive a restart, and tasks whose legal step order is known. Leave continuation to the model when the path genuinely varies per task.

When the workflow is narrow, high-volume and stable, exemplars have grown long without fixing format or tool-selection errors, and thousands of verified trajectories exist. Fine-tuning moves the scaffolding into the weights, buying a shorter prompt at the price of a retrain whenever the tools change.

There is no universal answer — set it per task class and prove it with an ablation. Thought tokens are billed on write and again on every later step that re-reads them, so verbosity compounds across a run while adding little to action quality on simple steps.