The Retrieval Problem Nobody Names

Every serious agent system eventually needs memory: the ability to look up how a similar situation was handled before and act consistently. The default answer in 2026 is vector RAG — embed everything, retrieve the top-k most similar chunks, stuff them into the context window.

For documents, that works. For decisions, it quietly fails. And the failure is structural, not a tuning problem.

A decision is not a paragraph. It's a small web of relationships: a proposition, the arguments for and against it, the evidence each argument leaned on, who approved the exception, and which past case it followed. Flatten that into text chunks and embed them, and retrieval hands back fragments with the relationships severed. You get the conclusion without the counterargument. You get the approval without the reasoning. You get a sentence that mentions a precedent without the precedent itself.

This is what practitioners call "chunk soup." It's why vector-only retrieval over decision logs feels confident and is subtly untrustworthy.

Chunk Soup vs. the Decision Packet

The difference isn't the embedding model or the chunk size. It's the substrate. One stores text about decisions; the other stores decisions as structure.

Why Normative Edges Change Everything

Generic knowledge graphs store descriptive edges: "mentions," "related to," "owned by." They tell you two things are connected but not why it mattered.

A decision graph stores normative edges — the relationships carry reasoning:

• supports / opposes — this argument pushed the decision toward or away from the outcome
• refutes — this evidence directly contradicts that claim
• qualifies / depends_on — this holds only under a condition

Because the edge type is the reasoning, the graph already knows what's load-bearing. Retrieval doesn't have to guess which of ten mentioned facts actually drove the call — the supports edges with high weight say so. Descriptive graphs enable search. Normative graphs enable judgment.

Why a Decision Graph Is "GraphRAG-Perfect"

Most teams that try GraphRAG on a general enterprise graph give up. The reasons are consistent, and a decision graph avoids every one of them:

The graph has "what mattered" built into its structure. That's the property GraphRAG needs and rarely gets.

The Hybrid Retrieval Pipeline

Vectors and graphs aren't rivals here. Decision retrieval uses vectors to find the entry points and graph structure to fetch the complete context. In AIAgentree this is a five-step pipeline (shipped in the precedent-search service):

Hard limits (max depth, max nodes, timeout) keep expansion from running away. The output is never a wall of tokens — it's a small number of complete, comparable decisions.

Retrieval For Agents: MCP and A2A

Memory is only useful if the agent can reach it while it reasons. AIAgentree exposes decision retrieval two ways:

The packet is portable by design — it carries everything needed to understand and apply the decision, which is exactly what makes it safe to pass across a trust boundary.

What It Looks Like In Code

Retrieving precedent for the decision an agent is about to make:

# Find how similar cases were decided before acting
results = client.search_precedents(
    query="refund above auto-approve threshold, premium customer",
    filters={"category": "customer_service", "maturity": "validated"},
)

for packet in results:
    # Each packet is a complete decision: proposition, pro/con
    # arguments, evidence, approvals, outcome, and cited precedents
    print(packet.proposition, packet.outcome, packet.confidence)

No prompt-stuffing of raw logs. The agent reasons over prior decisions, with their reasoning attached. The snippet uses the Python client for clarity — but the same retrieval (get_packet, search_precedents) is available over MCP with no SDK, so an MCP-native agent consumes decisions as tools.

The Full Stack Is Shipped

We'd rather be precise than impressive. Here's what's live today:

The full closed-loop flywheel is live: outcome feedback flows back into precedent rankings, argument effectiveness surfaces what worked, and agents get relevant precedents auto-suggested when they seal a decision. The graph substrate makes it possible — and now the self-improving layer runs on top of it.

What This Does Not Replace

• Your vector database — it's a component of the pipeline, step 1
• Your document RAG — retrieving policies and manuals is a different job
• Observability tools — spans, latency, and token metrics still belong to LangSmith/Langfuse et al.

Decision GraphRAG sits on top of all of them and captures the artifact none of them stored: the structured decision, retrievable with its reasoning intact.