The Trust Gap in Agentic AI

Ask an AI agent why it did something, and in most stacks today the honest answer is: “Because it was in the context window at the time.”

That answer is fine for a chatbot. It isn’t fine for an agent that rolls back a production change, approves a supplier, flags a contract clause or escalates a customer case. When the action matters, the enterprise has to answer harder questions:

  • Knowledge: What did the agent actually know?
  • Provenance: Where did each fact come from, and was it current?
  • Access: Was the agent allowed to see it?
  • Contradictions: What contradicted it, and was that considered?
  • Approval: Who approved the action, and what were they shown?

Many agent architectures can’t answer these without reconstructing the story from logs, and some can’t answer them at all. That is the trust gap in agentic AI. Closing it takes a layer most agent stacks don’t have yet: an evidence fabric.

The Ever-Growing Prompt Problem

Passing text between agents is the default way to share knowledge, and it breaks down quickly in production. A research agent writes up its findings, the orchestrator reads them, and the next agent gets a summary of the summary. Every handoff makes the prompt longer, and here is what goes wrong:

  • Cost Climbs: The orchestrator rereads everything every agent produced, whether or not it matters to the decision at hand.
  • Signal Gets Buried: The one fact that matters sits among dozens that don’t.
  • Provenance Disappears: A summary of a summary no longer points to the source, version or timestamp it came from.
  • Knowledge Evaporates: When an agent finishes, what it learned lives only in a transcript, and the next agent starts from scratch.
  • Risk Spreads: Anything in context is visible to every step, so text injected into one document can travel through an entire chain of agents. The OWASP AI Agent Security Cheat Sheet lists cascading failures, where one compromised agent passes an attack on to others, among the key risks of multi-agent systems.
  • Nothing Can Be Replayed: You can’t re-check a decision if you can’t reconstruct exactly what it relied on.

The context window is a scratchpad. Enterprises have been treating it as a system of record.

What Is an Evidence Fabric?

An evidence fabric is a shared, governed layer of facts, artifacts, sources, confidence and contradictions that lives with the workflow, not inside any single agent.

Every participant contributes to it: agents, people, live systems, documents, telemetry and specialist tools. Every reasoning step draws from it selectively, receiving only the evidence relevant to the decision in front of it, with source and history attached. When an agent finishes, its findings stay.

It’s easy to confuse an evidence fabric with layers enterprises already run. Here is how it compares:

  • Context Window: Holds whatever was pasted into a single call, but has no persistence, provenance or access control.
  • Agent Memory: Holds one agent’s notes across sessions, but offers no shared truth, scoping or contradiction handling.
  • Vector Store and RAG: Finds text chunks that look similar to a query, but doesn’t track whether a claim is supported or contradicted, or which decisions relied on it.
  • Logs and Traces: Record what happened step by step, but not what was believed to be true, or why.
  • Data Fabric: Provides integrated access to enterprise data, but not the claims made about one specific piece of work or how they were used.
  • Evidence Fabric: Holds claims, their sources, conflicts and confidence, and the decisions that relied on them. It is built for exactly this job.

Retrieval finds text. Logs record events. An evidence fabric records what the workflow believes, why it believes it and what it did about it.

The Building Blocks

You don’t need exotic technology to build an evidence fabric. You need discipline about a small set of objects:

  • Sources with Identity: Every input, whether a document, an API response, a metric window or a human decision, gets an immutable reference, a version, a timestamp and an access policy.
  • Addressable Evidence: Not “see the PDF,” but the exact span, table cell, log line or API field that supports a fact.
  • Claims: Typed statements of what the workflow believes, with subject, attribute, value, unit and time scope. Claims, not paragraphs.
  • Links with Roles: Each piece of evidence supports, contradicts or qualifies a claim. Contradictions are first-class, not averaged away.
  • Confidence and Freshness: How strong the support is and how current the source is, with thresholds set by policy, not by the model’s own self-assessment.
  • Decisions: Each outcome is tied to the claims it relied on, the rules that fired and the person who approved it.
  • Run Records: Which model, prompt, tool and policy versions produced each claim.
  • Identity-Scoped Access: Each participant sees only the evidence its delegated authority allows.

One principle runs through all of it: unknown stays unknown. If the evidence isn’t there, the fabric records a gap. It doesn’t let a model fill that gap with a plausible guess.

Why It Matters

Six things get easier once the evidence lives in one governed place:

  • Audit and Compliance Become a Query: NIST’s Generative AI Profile includes provenance and human oversight among its suggested actions. An evidence fabric applies the same discipline to agent decisions, so “Why did the system do this?” gets a direct answer: these claims, from these sources, checked by these rules, approved by this person.
  • Agents Work from Less Context: When reasoning draws on structured evidence instead of a growing transcript, each step reads only what it needs. Costs tend to fall, and the facts that matter stay visible.
  • Human Oversight Stops Being a Formality: The AWS Well-Architected Agentic AI Lens warns that routing every agent action through human review produces rubber-stamp approvals. With an evidence fabric, the reviewer sees the proposed action, the highlighted source, the counterevidence and the open gaps, which is enough to decide quickly and well.
  • Change Has a Known Blast Radius: When a contract is amended, a policy is updated or new telemetry arrives, the fabric knows which claims depended on the old evidence. Only those claims, and the decisions built on them, need to be re-checked.
  • Failures Become Diagnosable: When something goes wrong, you can tell whether the problem was missing evidence, wrong evidence or bad reasoning over good evidence. Each needs a different fix.
  • Security Holds Across Handoffs: Evidence is data, never instructions. Agents exchange typed claims that are revalidated at every boundary, not raw transcripts that carry whatever was injected upstream.

Together, these turn agent decisions from something you have to reconstruct into something you can simply look up.

An Illustrative Example: A Production Incident

The scenario below is hypothetical, and its times and details are invented. At 02:14, an alert fires: API latency has spiked in one region. Specialist agents, an orchestrator and one on-call engineer get involved:

  • Telemetry Agent: Records a claim that p99 latency in region A rose sharply at 02:02, with the metric window as its evidence.
  • Change Agent: Records a claim that a configuration change was deployed to region A at 01:50, with the deployment record as its evidence.
  • Second Telemetry Check: Adds a qualifier noting that region B received the same change and shows no spike.
  • Runbook: Retrieved from the knowledge base, it states that a rollback in this tier needs on-call approval.
  • Orchestrator: Proposes a rollback for region A only, reading four claims instead of the full transcripts of three agents.
  • On-Call Engineer: Sees the proposal, the evidence behind it and the region B qualifier, then approves. The approval joins the fabric.

Six weeks later, an auditor asks why region A was rolled back. Nobody has to rebuild the story from chat logs and dashboards. The answer is already a single connected record.

How We Approach This at Aizen

The Evidence Fabric is one of the core pillars of Aizen Orchestrate, our durable, identity-governed runtime for enterprise agent work. Our guiding principle is simple: reason from evidence, not from an ever-growing prompt.

  • Built from Everything the Work Touches: Orchestrate builds the evidence layer from APIs and live systems, documents and contracts, specialist findings, human decisions, telemetry and observability, and ERP and business records.
  • Shared Truth for the Workflow: Facts, artifacts, sources, confidence and contradictions stay with the workflow after the agent that produced them has finished.
  • Selective Context: Each reasoning step receives the evidence needed for the decision at hand. In Aizen’s multi-agent reference architecture, worker agents produced about 4,000 tokens, and selective context let the orchestrator synthesize from roughly 800 of them, about 80% fewer orchestrator tokens. That is a reference workload, not a guaranteed saving, and actual economics vary by workflow.
  • Governed by Identity: Delegated user identity is downscoped at every agent boundary, so each participant sees and does only what it is authorized to.
  • Replayable: Every run can be replayed step by step, with full audit lineage.

Because the Evidence Fabric sits inside a durable workflow, known decisions stay deterministic, approvals are first-class steps and the evidence trail is recorded as the work happens, not stitched together after the fact.

The Takeaway

In agentic AI, the answer is the cheap part. Any capable model can produce one. What enterprises need, and what auditors, risk teams and customers increasingly ask for, is the evidence behind it. Agents come and go. The evidence should stay.

Explore the Aizen Orchestrate architecture to see how the Evidence Fabric is built into every workflow.

‍