ReAct: how reasoning plus tools reduces hallucinations

Models can sound confident even when they don’t know. The way out is rarely “think harder”. It’s “verify”.

ReAct is a pattern that pairs reasoning with action: the model decides what it needs to check, uses a tool (search, database, calculator, tests), and only then commits to a claim. It’s not magic. It’s a feedback loop with reality.

Claims Framework

What this article claims: The ReAct pattern (thought-action-observation) reduces hallucinations by forcing the model to verify claims with external tools before answering; pure language-based reasoning without feedback is insufficient for factual reliability.

What it is based on: Yao et al. (2022/2023) published at ICLR 2023; comparisons with CoVe (Dhuliawala et al., 2023), DoLa (Chuang et al., 2023), and Reflexion (Shinn et al., 2023).

Where it simplifies: The article does not present quantitative benchmarks showing the degree of hallucination reduction; it does not discuss orchestration costs and latency; it assumes the availability of high-quality tools, which may not hold in practice.

Why pure reasoning isn’t enough: “knowing” vs. “being able to check”

LLMs have two modes that look similar from the outside:

Stored knowledge: patterns remembered from training.
Fluent completion: the ability to produce a plausible story when evidence is missing.

In a standard chat, those blur together. You ask a factual question. The model gives a detailed answer. It feels like knowledge.

But without external feedback, the model often does what it’s optimized for: fill gaps with the most likely narrative. Sometimes that narrative is right. Sometimes it’s a hallucination. Without a checkpoint, you can’t tell.

ReAct starts from a simple idea: don’t force the model to “know”. Let it “find out”.

The ReAct loop: thought → action → observation

ReAct is usually expressed as a short loop:

Thought: What do I need to verify? What’s my check plan?
Action: Call a tool (search, DB query, calculation, tests).
Observation: Record the tool output as a new fact.

The third step is the lever. Observation forces the system to work with concrete evidence instead of vibes.

This changes the failure modes. Instead of free-form confabulation, you get errors you can debug:

the wrong tool,
the wrong query,
the wrong interpretation of evidence,
or “right fact, wrong conclusion”.

Where ReAct helps most (and why)

ReAct shines when verification is fast and reasonably cheap, for example:

calculations (a calculator or script),
database or log queries,
checking a specific detail in docs,
consistency checks (linter, tests, schema validation).

Notice how broad that is. “Tools” are not just web search. In code, the tool can be pytest. In a company, the tool can be a CRM export. In policy, the tool can be an internal knowledge base.

Where observation exists, the output stops being “an answer” and becomes an auditable process.

Where ReAct fails: tools are not truth

ReAct doesn’t guarantee correctness. It adds moving parts.

Common failures:

Tool ≠ authority. Search returns what’s available, not what’s true.
Bad queries. Wrong questions produce wrong observations.
Stale data. Docs and databases can be outdated.
Step-skipping. Agents can pretend they checked to save tokens/time.

ReAct needs rules. Otherwise it becomes “calling APIs for comfort”.

Designing rules: how to force “verify before you claim”

ReAct is half architecture and half discipline. In practice, that means setting policies like:

No numbers without sources. Percentages and metrics require traceable references.
Stop conditions. When to admit uncertainty and ask for missing inputs.
Mandatory observations for key claims. For high-stakes factual statements: tool-first.

The same logic works in human teams. “Claim → evidence” reduces confident nonsense.

ReAct vs. other reliability techniques: CoVe, DoLa, Reflexion

ReAct is one tool in a broader toolbox:

Chain-of-Verification (CoVe) uses verification questions when external tools aren’t available.
DoLa aims to improve factuality at decoding time (inference-time mitigation).
Reflexion supports iterative improvement with reflection and memory.

Practical intuition:

If you have tools, use ReAct.
If you don’t, use CoVe or multiple models.
If the task repeats, consider Reflexion-style iteration.

Conclusion: ReAct as a baseline for trustworthy agent workflows

ReAct isn’t about “more intelligence”. It’s about less room for ungrounded storytelling. Thought–action–observation is how you keep the system anchored.

If “verify before you claim” matches your quality bar, CrossChat is a good place to make that discipline explicit in a workflow and combine it with multiple models.

Sources

Yao et al. (2022/2023). ReAct: Synergizing Reasoning and Acting in Language Models. ICLR 2023. arXiv:2210.03629. DOI: 10.48550/arXiv.2210.03629.
Dhuliawala et al. (2023). Chain-of-Verification Reduces Hallucination in Large Language Models. arXiv:2309.11495. DOI: 10.48550/arXiv.2309.11495.
Shinn et al. (2023). Reflexion: Language Agents with Verbal Reinforcement Learning. arXiv:2303.11366. DOI: 10.48550/arXiv.2303.11366.
Chuang et al. (2023/2024). DoLa: Decoding by Contrasting Layers Improves Factuality in Large Language Models. arXiv:2309.03883. DOI: 10.48550/arXiv.2309.03883.

Editorial History

Concept: Codex CLI + GPT-5.2 Version 1: Codex CLI + GPT-5.2 Quality audit (2026-03-23, Claude Code + Claude Opus 4.6): added Claims Framework, verified sources, language polish.