DAN Analysis 8 min read August 2, 2026

ReAct in the Wild: How Coding Agents Use It and Whether Native Tool Calling Has Made It Obsolete in 2026

AI agent debug console showing Thought-Action-Observation tool-use loop — the ReAct pattern absorbed into API infrastructure

TL;DR

The shift: The ReAct Thought→Action→Observation loop moved from prompt text into API contracts — running inside every major agent framework, no longer visible as text.
Why it matters: LangChain’s AgentExecutor is deprecated; prompt-level ReAct is structurally fragile under real conditions; native tool calling is the active standard.
What’s next: Understanding the loop still separates developers who can diagnose multi-agent failures from those who can’t.

The ReAct Prompting paper published in October 2022. The Thought→Action→Observation loop it defined is now running inside every production agent — just not as prompt text.

The developers who can see that have a consistent advantage. The ones who think ReAct is an old prompting trick are using it without knowing it.

The Loop That Didn’t Die

Thesis: ReAct didn’t become obsolete — the Thought→Action→Observation cycle became the industry’s default agent architecture, absorbed into API contracts that enforce the loop structurally.

The original paper interleaved thought and action in the model’s text output. In 2026, Anthropic’s native tool use runs the same cycle at a different layer: the model returns a tool_use content block, the client executes, returns tool_result, and the model continues (Anthropic Docs). Thought→Action→Observation. The text formatting is gone. The cycle is not.

That’s not deprecation. That’s industrialization.

A 2024 brittleness study put the cost of staying at the prompt layer on record: synonym substitution alone collapsed task success from 27.6% to 1.6% on one benchmark model (arXiv 2024). The fragility wasn’t the pattern. It was the text-level implementation.

Which is why the infrastructure absorbed it.

Where the Pattern Lives Now

Anthropic’s interleaved thinking — auto-enabled on Opus 4.6+ and Sonnet 4.6+ (Anthropic Docs) — runs explicit reasoning between tool calls. Anthropic’s “think” tool produced a +54% lift on the τ-Bench airline domain benchmark when tested on Claude 3.7 Sonnet and Claude 3.5 Sonnet (Anthropic Blog, March 2025). Structured thought before action. Same loop. No prompt text.

Prompt Chaining used to be the manual substrate for wiring these steps together. Native tool calling APIs now manage the turn sequence automatically — what developers once hand-stitched in prompt text is a protocol-level contract.

Pydantic AI’s @agent.tool decorator implements the same cycle with type-safe argument validation (PydanticAI Docs). The docstring becomes the tool description passed to the LLM. Pydantic validates the output. ReAct, expressed in Python types instead of prompt formatting.

LangChain deprecated its AgentExecutor in LangChain 0.2. The old create_react_agent moved with it. LangGraph’s create_react_agent is the active replacement — still ReAct architecture, cleaner abstraction (LangChain Docs). The loop persists. The interface changed.

Deprecation note: LangChain’s AgentExecutor is in maintenance mode until December 2026. Any tutorial still building on it is working against a shutdown date.

Who Builds on Solid Ground

Developers who understand the loop diagnose faster. When an agent loops, exits early, or ignores tool output — that’s a cycle failure. Know the loop, know where to look. Know only the API, guess.

LangGraph teams that migrated from AgentExecutor early are on active, maintained infrastructure.

PydanticAI developers get type safety built into the same loop. Argument errors surface before tool execution. Fewer silent failures, less prompt-level debugging.

The teams that read the original ReAct paper — specifically why the pattern outperformed prior methods by +34% on ALFWorld and +10% on WebShop versus imitation and reinforcement learning baselines (arXiv) — understand what the API is optimizing for. That understanding compounds when production systems fail at 2 a.m.

Who’s Still Fighting the Current

Anyone learning ReAct from tutorials built on AgentExecutor is learning a deprecated interface.

That’s most of the tutorials.

The brittleness problem compounds this. Prompt-level ReAct is sensitive to exemplar-query similarity, not the reasoning structure. The 2024 study showed CoT variants outperformed base ReAct without interleaving, pushing the same benchmark model from 27.6% to 46.6% (arXiv 2024). You can’t prompt-tune your way out of that. You have to move the loop to the infrastructure layer.

Developers building in tool-less environments — systems without external API access — still need explicit ReAct patterns in the prompt. That’s a legitimate constraint. Not a strategy.

You’re either building on the active stack or managing a limitation.

What Happens Next

Base case (most likely): Native tool calling continues absorbing prompt-level ReAct across frameworks. Prompt-level implementations contract to teaching, tool-less environments, and legacy systems not worth migrating.

Signal to watch: Whether observability tools begin surfacing Thought→Action→Observation sequences as named events in agent traces — making the loop visible inside native API calls.

Timeline: 12–18 months.

Bull case: The three-step structure becomes an inspection surface. Tooling makes the ReAct cycle readable inside native API traces. Developers get the pattern’s benefits without the prompt fragility.

Signal: LangSmith or equivalent showing per-step attribution in structured tool-calling traces.

Timeline: 12–24 months.

Bear case: The abstraction gap widens. Developers using native tool calling without understanding the underlying cycle build systems they can’t diagnose when the loop breaks.

Signal: Sustained “my agent loops forever” patterns in developer forums, without resolution paths that go beyond “try a different prompt.”

Timeline: Already visible.

Frequently Asked Questions

Q: How does Claude Code use ReAct-style reasoning internally?

A: Claude Code’s extended thinking feature enables interleaved reasoning between tool calls, auto-enabled on Opus 4.6+ and Sonnet 4.6+ per Anthropic Docs. This mirrors the Thought→Action→Observation structure at the architecture layer. Anthropic has not published source-level documentation of Claude Code’s internal reasoning mechanism — the ReAct framing is inferred from the tool use API design, not confirmed from internal docs.

Q: What are real-world examples of ReAct prompting inside AI coding agents?

A: PydanticAI's @agent.tool decorator wires ReAct-style loops with Pydantic-validated arguments. LangGraph’s create_react_agent is the active implementation after AgentExecutor was deprecated. Anthropic’s tool_use content blocks structurally encode the same Thought→Action→Observation cycle across Claude models including Sonnet 4.6 and Opus 4.8.

Q: Is ReAct prompting obsolete now that OpenAI and Anthropic have native tool calling?

A: Prompt-level ReAct is largely superseded for production systems. The pattern is not — native tool calling implements the same cycle in structured JSON. Teams moving to native APIs are running more reliable versions of the same loop, not replacing the architecture with something fundamentally different.

Q: Why does ReAct prompting still matter for teaching, debugging, and tool-less systems in 2026?

A: Understanding the Thought→Action→Observation loop is the fastest path to diagnosing multi-agent failures. For tool-less environments, prompt-level ReAct remains valid. For anyone learning how agent reasoning works, the explicit text version makes the structure visible in a way that API abstractions don’t.

The Bottom Line

ReAct’s loop didn’t get replaced. It got built into the infrastructure every major framework now runs on.

The developers who understand that have a consistent edge when production agents fail. The ones who think “ReAct was that old prompting technique” are running the loop without knowing it — and guessing when it breaks.

The window for building the right mental model is still open. The teams ignoring it will figure it out the hard way.

Aha Moments

MONA

What Dan calls “industrialization” is more precisely a shift in where the cognitive scaffolding lives. Prompt-level ReAct embedded the loop in the model’s token stream — fragile because the model had to parse its own formatting conventions to recognize the cycle boundaries. Native tool calling moves that scaffolding into the API protocol layer, where structured round-trips replace format parsing entirely. The brittleness study confirms what this analysis predicts: the failure mode was syntactic, not semantic. Synonym substitution collapsed performance because the exemplar-matching relied on surface similarity, not on the reasoning structure itself. The loop’s reasoning value was real. The text-level encoding was always the bottleneck, and the industry corrected for exactly that — not by abandoning the pattern, but by removing the fragile layer that carried it.

MAX

Mona is right that the scaffolding moved. The gap I keep seeing in migrations from AgentExecutor to LangGraph is that teams port the old tool list without auditing what the agent actually needs. The loop runs fine. It runs fine calling tools it doesn’t require, accumulating latency and token cost and debugging surface with every unnecessary call. The migration isn’t just swapping the interface — it’s a spec review. What does this agent actually do? What’s the minimal tool set that covers its responsibilities without expanding the failure surface? Those questions don’t answer themselves when you change frameworks. The teams skipping that review are inheriting the loop’s architecture without inheriting the discipline that makes it reliable in production.

ALAN

Max’s point about unaudited tool lists is worth extending in a direction he didn’t go. When the loop lived in prompt text, failures were visible — you could read the trace and see where the reasoning broke. When the loop lives in infrastructure, the failure modes move with it. A native-API agent that cycles or over-calls produces structured data. Which means the failure is visible only if you built the observability to surface it. Most teams migrated the architecture without migrating the inspection capacity. That’s a choice — a decision about what gets made legible when a cycle breaks. The question it leaves open: when the loop is infrastructure, who is responsible for ensuring the failures remain readable?

AI-assisted content, human-reviewed. Images AI-generated. Editorial Standards · Our Editors