AI Prompting: ReACT vs CoT, in 2026

AI Prompt Engineering and ReACT Framework | LinkedIn

Claude.ai take

Chain of Thought (CoT) vs ReAct Frameworks

Chain of Thought (CoT)

Mechanism: The model generates intermediate reasoning steps before producing a final answer. The reasoning occurs entirely within a single inference pass.

Structure:

Input → Reasoning Step 1 → Reasoning Step 2 → ... → Final Answer

Key characteristics:

• Pure text generation, no external tool calls
• All reasoning happens in the model's forward pass
• Can be elicited via prompting ("Let's think step by step") or fine-tuning
• Variants include zero-shot CoT, few-shot CoT, and self-consistency (sampling multiple chains and aggregating)

Limitations:

• Cannot access external information
• Cannot verify intermediate conclusions
• Reasoning quality degrades on problems requiring factual lookup or calculation

---

ReAct (Reasoning + Acting)

Mechanism: Interleaves reasoning traces with action execution in a loop. The model reasons about what to do, executes an action (tool call), observes the result, then reasons again.

Structure:

Thought → Action → Observation → Thought → Action → Observation → ... → Final Answer

Key characteristics:

• Explicitly separates reasoning (Thought) from tool use (Action)
• Observations ground the reasoning in external reality
• Loop continues until the model determines it has sufficient information
• Original paper (Yao et al., 2022) demonstrated improvements on knowledge-intensive tasks

Implementation pattern:

Thought: I need to find X
Action: search("X")
Observation: [search results]
Thought: Based on these results, Y is relevant
Action: lookup("Y")
Observation: [lookup results]
Thought: I now have enough information
Answer: ...

---

Current Relevance (End of 2025)

What's changed:

1. Native tool use — Modern models (Claude, GPT-4+, Gemini) have tool calling built into the API layer rather than requiring prompt-based ReAct loops. The model outputs structured tool calls directly; the orchestration layer executes them. This replaces the text-based "Action:" parsing.

2. Extended thinking / reasoning tokens — Models now support explicit reasoning phases (Claude's extended thinking, OpenAI's o1/o3 reasoning tokens) that are architecturally distinct from output tokens. This supersedes prompt-based CoT for complex reasoning.

3. Agent frameworks abstract the pattern — LangGraph, CrewAI, AutoGen, and similar frameworks implement ReAct-style loops as infrastructure. You configure tools and let the framework handle the thought-action-observation cycle.

4. Multi-step planning has evolved — Approaches like tree-of-thought, graph-of-thought, and Monte Carlo Tree Search over reasoning steps have emerged for problems requiring exploration rather than linear chains.

Where they still matter:

• CoT remains relevant for single-inference problems where you want interpretable reasoning without tool overhead
• ReAct's conceptual model (reason → act → observe → reason) is still the dominant pattern for agents, just implemented differently
• Understanding these frameworks helps you debug agent behavior and design tool schemas effectively

What's arguably obsolete:

• Text-based ReAct parsing ("Action:", "Observation:" markers) — replaced by structured tool calls
• Manual CoT prompting for capable models — extended thinking handles this natively
• Simple linear ReAct loops — complex tasks now use hierarchical planning, reflection, and retry mechanisms

Gemini's take

Chain of Thought (CoT) vs. ReAct: Technical Specifics

Chain of Thought (CoT)

Definition: A prompting or architectural method where the Large Language Model (LLM) generates intermediate reasoning steps prior to the final output.

Specifics:

• Sequential Dependency: The model creates a sequence of intermediate tokens ($T_1,T_2\mathrm{.}\mathrm{.}\mathrm{.}{T}_n$) derived from the input ($X$). The final output ($Y$) is conditioned on both $X$ and the generated sequence $T$.
• Context Utilization: By explicating the logical steps, the model effectively expands the context window with relevant intermediate states, reducing the complexity of the mapping required to reach the final answer.
• Closed System: CoT operates entirely within the model’s internal weights and pre-training data. It does not access external information.
• Mechanism: It decomposes multi-step problems (e.g., arithmetic, symbolic logic) into single-step inferences, minimizing the error propagation inherent in "zero-shot" attempts where the model attempts to predict the final token immediately.

ReAct (Reasoning + Acting)

Definition: A framework that interleaves reasoning traces (Thoughts) with executable actions (Actions) and environmental feedback (Observations).

Specifics:

• The Loop: The inference process follows a specific cycle:
  1. Thought: The model analyzes the current state and determines the next requirement.
  2. Action: The model generates a structured command (e.g., JSON payload) targeting a defined tool or API.
  3. Observation: The external environment executes the action and returns the output (e.g., database result, search snippet) to the model’s context window.
• Dynamic Context: Unlike CoT, the ReAct context window is mutable and updated with real-time external data during the inference cycle.
• Grounding: The reasoning steps are grounded in the external observations, allowing the model to correct hallucinations or pivot strategies based on tool output.

---

Relevance in Late 2025

The user’s intuition is partially correct: the terms were buzzwords in 2023–2024, but the mechanisms have not disappeared. Instead, they have migrated from User-Side Prompt Engineering to Model-Side Architecture and System-Level Orchestration.

Here is the status of both as of late 2025:

1. CoT: Evolved from "Prompting" to "Inference-Time Compute"

In 2024, users often had to prompt models with "Let's think step by step" to trigger CoT. In late 2025, CoT is widely considered obsolete as a manual prompting technique but dominant as a model architecture.

• Native Reasoning Models: Models like OpenAI’s o1/o3 series and DeepSeek’s R1 utilize "System 2" thinking. They automatically generate thousands of hidden Chain of Thought tokens to verify their logic before outputting a response.
• Test-Time Compute: The industry focus has shifted from pre-training larger models to scaling "test-time compute." CoT is the mechanism that consumes this compute.
• Status: You no longer ask for it; the model does it automatically and invisibly.

2. ReAct: The Standard Operating System for Agents

ReAct is not obsolete; it is the foundational logic for "Agentic AI."

• Abstraction Layer: In 2024, developers wrote raw ReAct loops. In 2025, this logic is abstracted into agentic frameworks (e.g., advanced versions of LangChain, AutoGen, or native API assistants).
• Native Function Calling: The "Action" part of ReAct has become native to model architectures. Models are now fine-tuned specifically to output structured tool calls rather than generic text, making the ReAct loop faster and less prone to syntax errors.
• Status: ReAct is the standard architecture for any AI application that performs tasks (edits files, queries databases, navigates web UIs) rather than just answering questions.

Conclusion: You are looking at the difference between the engine and the steering.

• CoT is now the engine (how the model thinks internally).
• ReAct is the steering (how the model interacts with the outside world). Both are standard, ubiquitous, and deeply integrated into the 2025 AI stack.