Part 7 — Agentic Patterns and the Accuracy Flywheel

7.1 “R1–R9 got the right context in hand — so why do I still need an agent?”

R1–R9 are feed-forward optimizations: they maximize the probability of having the right context beforegenerating. Necessary, but not sufficient — because retrieval quality isn’t fully knowable before retrieving, and answer quality isn’t fully knowable before generating.

The residual failures are exactly the cases that need an agent: a component that observes the current state, grades the quality, and decides the next action. The cost (extra LLM calls, latency, spend) is real, so the operating discipline is to apply it selectively — cheap guardrails run on every query, expensive patterns fire only when a cheaper gate says they must. That cost ladder is the mental model for the whole page:

The seven patterns, cheapest first. A1 router and A6 budget are near-free and always on. A2 CRAG and A3 Self-RAG add a grading/verification call, but only when retrieval or generation actually happened. A5 citation is a prompt constraint (near-free). A4 fan-out and A7 tool-use are the expensive ones — and they fire only for confirmed multi-hop or when the corpus falls short. See the cost-ladder diagram below.

7.2 “How do I catch the seven ways the answer still goes wrong?” — the agentic patterns

# CRAG core: grade_documents node + conditional edge
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("grade_documents", grade_documents_node)

workflow.add_edge("retrieve", "grade_documents")
workflow.add_conditional_edges(
    "grade_documents",
    decide_to_generate,
    {
        "transform_query": "transform_query",
        "web_search": "web_search",
        "generate": "generate",
    },
)

workflow.add_conditional_edges(
    "generate",
    grade_generation_v_documents_and_question,
    {
        "not supported": "generate",      # Hallucination: regenerate
        "not useful": "transform_query",  # Correct but irrelevant: re-retrieve
        "useful": END,                    # Quality gate passed
    },
)

def parallel_retrieve(state: GraphState) -> list[Send]:
    return [
        Send("retrieve_subquery", {"query": q, "tenant_id": state["tenant_id"]})
        for q in state["sub_queries"]
    ]

workflow.add_conditional_edges("planner", parallel_retrieve, ["retrieve_subquery"])
workflow.add_node("fuse_results", rrf_fusion_node)

# A5: force a citation on every claim. The constraint lives in the synthesis prompt.
CITED_SYNTHESIS = """Answer using ONLY the numbered context chunks below.
After every factual sentence, cite the chunk it came from as [chunk_id].
A sentence with no citation is not allowed — if you can't cite it, don't say it.

{numbered_context}

Question: {question}"""

# A6: cap the loops. Past the budget, hedge instead of spinning.
config = {"recursion_limit": 6}          # e.g. ≤6 total node steps of correction
try:
    result = app.invoke(initial_state, config=config)
except GraphRecursionError:
    result = hedged_answer(initial_state)  # “Based on available sources, likely… (unverified)”

7.3 “What does the whole thing look like assembled?” — the complete LangGraph structure

This graph is not a pipeline. A pipeline has one path. This graph has multiple conditional paths, loops with termination conditions, and parallel branches. Its accuracy comes precisely from being able to observe intermediate results and change course. The operating sequence across the patterns is: route (A1) → retrieve/fan-out (A4) → grade (A2) → generate + cite (A5) → verify (A3) → fall back to tools if needed (A7), all bounded by the budget (A6).

By this point the two failure planes are fully covered: the retrieval patterns R1–R9 from Part 6 handle F1–F8 feed-forward, and the agentic patterns here catch the residual F5/F6/F7 at generation time and F8 at routing time. Nothing in the F-list is left without a fix.

7.4 “How do I even know it’s improving?” — the three observability functions

Patterns are only as good as their ability to improve over time. A static system decays as the corpus changes, query distributions shift, and information needs evolve. The observability and human-review architecture creates a compound accuracy flywheel: the system produces traces → traces are evaluated → failures are reviewed → reviews become golden data → golden data improves the system → the improved system produces better traces.

7.5 Failure mode → metric → action

7.6 “Does it actually get better on its own?” — the compound accuracy flywheel

Yes — and not from engineering effort at deployment time, but from the structural loop between the system’s own uncertainty signals and the human knowledge that corrects them. Every hallucination the system detects (A3) becomes a golden example; every golden example tightens the next evaluation; every evaluation gates the next change. The longer it runs, the more it has corrected.