AgenticRAG-Survey

Enables autonomous agents to evaluate their own outputs and decisions by implementing a feedback loop where agents assess correctness, identify errors, and determine areas for improvement. This pattern integrates introspection mechanisms that allow agents to critique their reasoning chains and trigger iterative refinement cycles without external intervention, forming the basis for self-correcting RAG pipelines.

Enables agents to create structured, hierarchical task plans by decomposing complex queries into sequential or parallel sub-tasks with explicit dependencies and execution order. The pattern uses LLM-based planning to generate task graphs that specify retrieval steps, reasoning stages, and tool invocations, allowing agents to orchestrate complex workflows autonomously rather than following fixed pipelines.

Implements a RAG system where distinct agents specialize in retrieval and generation, coordinating through shared context or message passing. The retriever agent focuses on finding relevant documents and evaluating retrieval quality, while the generator agent synthesizes responses from retrieved context. This separation enables specialization where each agent optimizes for its specific task while maintaining coordination through explicit communication protocols.

Organizes agents in a hierarchical structure where high-level agents handle task decomposition and coordination, mid-level agents manage specialized domains or processing stages, and low-level agents execute specific operations. Information flows up and down the hierarchy, with higher-level agents making strategic decisions and lower-level agents executing tactical operations. This enables scalable organization of complex reasoning across many agents with clear responsibility boundaries.

Implements RAG systems with explicit feedback loops where agents detect retrieval or generation failures and trigger corrective actions. When agents identify that retrieved context is insufficient or generated responses are inaccurate, they autonomously adjust retrieval strategies (e.g., different query formulation, expanded search scope) or re-generate responses with corrected reasoning. This pattern enables self-correcting systems that improve output quality through iterative refinement driven by internal error detection.

Implements RAG systems that dynamically adjust retrieval and generation strategies based on query analysis, task complexity, and available resources. Agents analyze incoming queries to determine optimal processing approach (e.g., simple retrieval vs multi-step reasoning, local vs remote execution) and select strategies that balance quality, latency, and cost. This pattern enables efficient resource utilization by matching processing complexity to query requirements rather than using uniform strategies for all queries.

Implements RAG systems that leverage knowledge graphs to structure information and enable semantic reasoning across entities and relationships. Agents traverse knowledge graphs to find relevant information, reason about entity relationships, and synthesize responses based on graph structure. This pattern enables more sophisticated retrieval and reasoning by treating knowledge as interconnected entities and relationships rather than flat documents, supporting complex queries that require understanding of semantic relationships.

Implements specialized workflows for processing and analyzing documents where agents manage document ingestion, chunking, indexing, and multi-stage analysis. Agents coordinate document processing pipelines, apply domain-specific analysis (e.g., contract analysis, research paper summarization), and synthesize insights across documents. This pattern treats documents as first-class entities with explicit processing workflows, enabling sophisticated document analysis that goes beyond simple retrieval.

Enables agents to invoke external tools, APIs, and knowledge bases through a schema-based function registry that defines tool capabilities, parameters, and return types. Agents parse tool invocation requests from LLM outputs, validate parameters against schemas, execute tools with error handling, and integrate results back into the reasoning loop. This pattern supports both synchronous tool calls and asynchronous tool chains with result aggregation.

Enables multiple specialized agents to work together on complex tasks by assigning distinct roles (e.g., retriever, analyzer, synthesizer) and implementing coordination mechanisms for task delegation, result aggregation, and conflict resolution. Agents communicate through shared context or message-passing protocols, with a coordinator agent managing task distribution and ensuring outputs from specialized agents are integrated coherently into final responses.

Structures complex tasks as sequences of dependent prompts where the output of one step becomes the input to the next, enabling step-by-step reasoning with explicit state transitions. Each step in the chain is a distinct LLM invocation with its own prompt, context, and validation logic, allowing agents to build up complex reasoning progressively while maintaining clear separation of concerns and enabling intermediate result inspection.

Classifies incoming queries or tasks and directs them to specialized processing pipelines or agents based on query type, complexity, or domain. The routing decision is made by an LLM-based classifier that analyzes query characteristics and selects the most appropriate handler from a registry of specialized processors, enabling efficient resource allocation and domain-specific optimization without requiring all queries to traverse the same pipeline.

Executes multiple independent tasks concurrently rather than sequentially, with explicit result aggregation and conflict resolution. The pattern identifies task independence, launches parallel executions, waits for all tasks to complete, and combines results using aggregation logic (e.g., voting, merging, ranking). This enables efficient utilization of computational resources and reduces total execution time for tasks with independent sub-components.

Implements a hierarchical coordination model where a central orchestrator agent analyzes tasks, decomposes them into sub-tasks, and delegates work to specialized worker agents. The orchestrator monitors worker progress, collects results, handles failures with retry logic, and synthesizes final outputs. Workers execute assigned tasks autonomously and report results back to the orchestrator, enabling scalable task distribution without requiring workers to understand the overall task structure.

Implements a feedback loop where an evaluator agent assesses outputs against quality criteria, identifies deficiencies, and an optimizer agent iteratively refines outputs based on evaluation feedback. The pattern cycles between evaluation and optimization until quality thresholds are met or iteration limits are reached. This enables continuous improvement of agent outputs without external intervention, with clear quality metrics driving the refinement process.

Implements a unified RAG system where a single agent manages both retrieval and generation within a single reasoning loop. The agent decides when to retrieve, what to retrieve, evaluates retrieved context, and generates responses iteratively. This architecture integrates all agentic patterns (reflection, planning, tool use) into a single agent's decision-making process, enabling end-to-end control over the RAG pipeline without inter-agent coordination overhead.