Esta nota todavía no está traducida, así que se muestra la fuente en inglés.

The ReAct loop: reason + act

Mental model: strip any agent to its skeleton and you find one loop — reason about the goal and current state, take an action (a tool call), observe the result, repeat until done. This is ReAct (Yao et al. 2022, arXiv:2210.03629). The paper's insight is that interleaving reasoning traces with actions beats either alone: reasoning grounds the next action in the latest evidence; observations ground the reasoning in reality.

From paper to production (what changed)

The original ReAct was a prompting pattern: few-shot examples teaching the model to emit Thought: / Action: / Observation: text that a parser executed. In 2026 the pattern is native: models are trained for tool use, "Thought" is the model's extended/adaptive thinking, "Action" is a structured tool_use block, and the loop is ~30 lines around the API. The conceptual structure survived; the brittle text parsing did not.

export async function agentLoop(task: string, opts = { maxTurns: 15, maxTokens: 150_000 }) {
  const messages: Anthropic.MessageParam[] = [{ role: "user", content: task }];
  let spent = 0;

  for (let turn = 0; turn < opts.maxTurns; turn++) {
    const res = await anthropic.messages.create({
      model: "claude-opus-4-8",
      max_tokens: 4096,
      thinking: { type: "adaptive" },   // the "Reason" half, handled by the model
      system: SYSTEM,                    // goal framing + stop criteria live here
      tools,
      messages,
    });
    spent += res.usage.input_tokens + res.usage.output_tokens;
    if (spent > opts.maxTokens) throw new AgentBudgetError(messages);

    if (res.stop_reason !== "tool_use") {
      return res.content.filter((b) => b.type === "text").map((b) => b.text).join("");
    }
    messages.push({ role: "assistant", content: res.content });
    messages.push({ role: "user", content: await executeAll(res.content) }); // the "Observe" half
  }
  throw new AgentTurnLimitError(messages); // surface the trace, don't swallow it
}

Three things make this production-shaped rather than demo-shaped: a turn cap, a token budget, and errors that carry the trace (you will need it — debugging is trace reading).

Why interleaving beats plan-then-execute alone

Pure upfront planning is brittle — the world rarely matches the plan (the file isn't where the plan assumed; the API returns an error the plan didn't anticipate). Pure acting is blind — without a reasoning step, the model pattern-matches its way into repeated failing actions. ReAct's per-step adaptation is why it became the default; planning survives as a layer on top of the loop (a revisable todo list), not a replacement for it.

The empirical caveat from the original paper still holds: ReAct's gains come mostly from grounding (fewer hallucinated facts, because the model checks), at some cost in flexibility — the model can over-anchor on an uninformative observation. Reflexion (Shinn et al. 2023, arXiv:2303.11366) adds verbal self-critique between attempts; modern models do a weaker version of this natively inside their thinking blocks.

What makes the loop work or fail

Observation quality is everything. The model decides the next step from what the tool returned — noisy, huge, or silent results derail the loop (ACI design).
Stop criteria must be explicit. Tell the model in the system prompt what "done" looks like ("when the test passes, reply with SUMMARY: ..."), and enforce caps in code. A loop with neither runs until the budget does.
Context grows every turn — thought + action + observation, accumulated. Past ~20 turns, memory management (compaction, external scratchpads) stops being optional.
Verification closes the loop. The strongest agents end with a checking action (run the tests, re-fetch the record) rather than trusting their own claim of success — cheap insurance against false-victory declarations.

Cost & latency lens

Each turn re-sends the whole accumulated conversation: token spend grows roughly quadratically in turn count, and per-task agent usage runs ~4× a chat interaction on Anthropic's production numbers. Defenses: prompt caching (append-only messages + byte-stable system/tools make every prior turn a ~0.1× cache read), a small model for mechanical turns if you route, and per-turn token telemetry in tracing — the loop is one span per turn, with tool spans nested, or you're blind. Latency is turns × (model latency + tool latency); the lever is fewer/parallel tool calls per turn, not faster prose.

Failure modes

Repetition loops — same action, same failing result, again. Detect programmatically (hash recent actions; two identical consecutive calls → inject a "this exact call already failed, change approach" message or abort).
Unbounded cost — the cap-less loop is a billing incident in waiting.
Context rot at long horizons — quality decays as the window fills with stale observations; see agent memory.
Anchoring on a bad observation — one misleading tool result steers everything after; actionable errors and verification steps are the antidote.

Connects to: tool calling · planning · loops · context management

Sources

Yao et al. 2022 — ReAct: Synergizing Reasoning and Acting (arXiv:2210.03629) — the pattern's origin; §4's error analysis (grounding vs reasoning failures) is still the best taxonomy.
Shinn et al. 2023 — Reflexion (arXiv:2303.11366) — self-critique between attempts; the ancestor of modern verify-then-retry loops.
Anthropic — Building Effective Agents (Dec 2024) — defines the agent as "LLM using tools in a loop based on environmental feedback" and the stop-condition discipline.
Anthropic docs — Tool use — the API mechanics the modern loop is built on.
Lilian Weng — LLM-Powered Autonomous Agents (2023) — the survey that placed ReAct among planning/memory/tools; dated on specifics, still the cleanest map.