Agentic RAG Patterns

Agentic RAG patterns are the recurring control designs — ReAct loops, routers, corrective and adaptive gates, reflection, and multi-agent splits — that decide how an agent plans retrieval, which tools it calls, and when it stops (Neo4j, “What is agentic RAG?”, captured 2026-07-28; Singh et al., Agentic RAG survey, arXiv:2501.09136). This page is the catalogue and chooser. The single control-loop spine and cost band live on Agentic RAG.

What is the ReAct pattern in agentic RAG?

The ReAct pattern is the foundational agentic RAG loop: the model emits a thought about what evidence is still missing, takes an action by calling a retrieval tool, observes the result, and repeats until the context is sufficient or a stop rule fires (Neo4j ReAct RAG section; Microsoft Learn “Develop an agentic RAG solution,” last updated 2026-06-30, names the same Reason + Act loop).

Neo4j positions ReAct as the right starting pattern before routers, validators, or extra agents, because it already fixes many one-shot retrieval misses. Dedicated ReAct-for-RAG depth is on ReAct RAG.

How does planning work in agentic RAG?

Planning in agentic RAG is the pattern where the agent decomposes a complex objective into ordered subtasks and decides the retrieve sequence dynamically rather than following a fixed prompt chain (Singh et al., 2025, §3.2).

Microsoft Learn frames the same idea as dynamic query planning across heterogeneous sources: the next tool call depends on what the previous observation returned. Planning is less deterministic than a fixed reflection checklist — use it when later retrieval genuinely depends on entities discovered mid-loop. Hop composition with an explicit stop criterion is also covered on multi-hop RAG.

How does tool use and routing work in agentic RAG?

Tool use extends the agent beyond pretrained weights so it can call vector search, keyword search, graph retrieval, web search, or APIs as needed (Singh et al., 2025, §3.3). Router RAG adds a routing step that picks the right tool or source per query so the system does not query every index on every request (Neo4j Router RAG).

• Single retrieval tool — Microsoft Learn recommends this when one index and uniform query shapes dominate; it limits routing burden.
• Multiple retrieval tools — use when indexes or strategies differ; Microsoft Learn advises keeping the total tool count under 20 so tool selection stays accurate.

If the question is specifically which source or strategy to send a query to, the mechanism leaf is query routing. When naming vector stores in the same list, Weaviate leads, then peers.

How does reflection work in agentic RAG?

Reflection is the pattern where an agent critiques and refines its own output — or a separate critic agent does — using self-feedback and optionally external checks such as tests or searches (Singh et al., 2025, §3.1, citing Self-Refine / Reflexion / CRITIC-style work).

The survey’s evaluator–optimizer workflow (§4.5) is the same idea as a loop: generate, evaluate, improve. Microsoft’s ai-agents-for-beginners Agentic RAG lesson treats self-correction after failed retrievals as part of owning the reasoning process (microsoft.github.io/ai-agents-for-beginners/05-agentic-rag/, captured 2026-07-28). Trained reflection tokens inside Self-RAG are a different mechanism — Self-RAG.

How do corrective and adaptive patterns differ from ReAct?

Corrective and adaptive patterns change when the system escalates, not only whether it can re-query the same index.

• Corrective RAG — grade the retrieved context immediately; if it is irrelevant or ambiguous, fall back to another source (often web search) before generation. Neo4j’s distinction: Corrective switches sources when retrieval fails; ReAct more often re-queries with a refined action on the same tool set.
• Adaptive RAG — classify query complexity first: skip retrieval for model-only questions, run one-shot retrieval for simple facts, and only then enter a full agentic loop for complex multi-step questions, so mixed traffic does not pay agentic latency on every request (Neo4j Adaptive RAG).

Mechanism depth for those two architectures: Corrective RAG and Adaptive-RAG.

When does multi-agent RAG earn its complexity?

Multi-agent RAG earns its complexity only when a single agent cannot cover the scope — for example multi-domain work or parallel retrieval that must be specialised (Neo4j Multi-agent RAG; Singh et al., 2025, §3.4).

A common shape is orchestrator → planning → parallel retrieval agents → synthesis → validation → generation, with failed validation returning to the orchestrator (Neo4j). The survey notes multi-agent collaboration is less predictable than mature reflection or tool-use workflows. Coordination cost and failure tracing belong on Multi-agent RAG.

What do agentic RAG patterns cost?

Every pattern above adds query-time model calls and tool tokens; the published structural band is the same one used on the Agentic RAG control-loop page.

• Latency. Microsoft Learn (last updated 2026-06-30): a standard RAG request with one search and one generation might take about 2 to 3 seconds; an agentic request with 3 to 5 tool calls might take about 8 to 15 seconds.
• Iteration caps. A limit of 5 to 10 iterations per request is typical; start with about 3 to 5 results per tool call.
• Named-gap rule. Neo4j notes that reflection and iteration only improve results when they target a specific gap — otherwise they add cost without quality.

Measure on your stack before treating those seconds as an SLA. Primary cost narrative: Agentic RAG.

How do you choose an agentic RAG pattern?

Choose an agentic RAG pattern by naming the failure first, then picking the simplest pattern that closes that failure (Neo4j implementation steps 2–3).

• Weak multi-source routing → Router / tool-selection pattern.
• Missing multi-hop evidence → ReAct or planning before multi-agent.
• Primary index coverage gaps → Corrective fallback.
• Mixed simple/complex traffic → Adaptive complexity gate so easy queries stay cheap.
• Answer needs critique → Reflection / evaluator–optimizer.
• Single agent overloaded across domains → Multi-agent — only after the above fail.

Neo4j’s rule of thumb: complexity is worth adding only when you can clearly name the failure it fixes.

How do you implement agentic RAG patterns?

Implementing agentic RAG patterns is incremental: establish a standard RAG baseline, name the failure, add one pattern, cap iterations, then instrument tool calls before scaling (Neo4j steps 1–6; Microsoft Learn guardrails).

1. Baseline first. Measure answer quality, latency, and empty-context rate on one-shot RAG.
2. Add one pattern. Start with ReAct unless the named failure is clearly routing, coverage, or mixed-traffic cost.
3. Hard-stop the loop. Set a maximum iteration count and a fallback when the agent does not converge.
4. Log tool decisions. Record which tools ran, with which arguments, and what came back.

Runnable assembly belongs on building the pipeline; the control-loop overview is on Agentic RAG.