DECISION EVIDENCE INFRASTRUCTURE FOR AI AGENTS

When AI agents act,LoopGrid proveswhat happened.

Capture the agent, delegated authority, model and policy context, human approval, external action and observed outcome — then seal them as portable evidence whose integrity and provenance can be verified independently.

Explore the interactive demo Design partner program

Runtimes execute. Observability explains. Control planes govern. LoopGrid proves.

Supported by

Inception

for Startups

Signed evidenceAppend-only historyPrivacy modesOffline verification

LOOPGRID SEAL

A decision becomes evidence.

VERIFIED

01 · DECISIONThe consequential action is proposed.

02 · EVIDENCEAuthority, policy and outcome are captured.

03 · HISTORYThe signed record can be verified later.

decision → evidence → history → verifyplays once · then stays sealed

01Not another trace.

Preserve accountability, not only telemetry.

02Not a workflow engine.

Keep n8n, Zapier, LangGraph or your own runtime.

03Evidence before reporting.

Incident, customer, audit and regulatory workflows can use the same underlying record.

04Independent by design.

Export the record and verify it outside the LoopGrid UI.

WHERE LOOPGRID SITS

A neutral evidence layer across the agent stack.

LoopGrid does not ask a team to rebuild around a new model, agent runtime or observability platform. It receives the decision stream through SDKs and open protocols, then preserves the evidence across systems.

“Can we reconstruct and prove the complete decision across all of these systems?”

DEFAULT

Out-of-band

Send evidence asynchronously through REST, SDKs or OTLP. Low latency impact and easy adoption.

HIGHER-RISK ACTIONS

Inline boundary

Use policy / human approval / MCP proxy paths before a consequential tool call executes.

BUSINESS WORKFLOW

SupportClaimsFinanceHROperations

↓

AGENT / ORCHESTRATION

n8nZapierLangGraphCustom runtime

↓

MODELS + TOOLS

OpenAIAnthropicMCP toolsStripe / CRM / ERP

EXISTING OBSERVABILITY / GOVERNANCE

LangSmithFiddlerDatadog

LOOPGRID

Evidence plane

AuthorityPolicyApprovalActionOutcomeProof

SEE THE EVIDENCE FORM

Watch one agent decision become verifiable evidence.

Want to inspect real signatures and test a mock business action? Open the synthetic evidence lab →

A $720 refund crosses a human-approval threshold. LoopGrid captures the accountable steps as they happen — who proposed it, which policy applied, who approved it, what tool ran and what outcome actually occurred.

CUSTOMER REQUEST

“I was charged twice. Refund the duplicate $720.”

Agent requests a consequential action

support-agent-04 · refund:create · delegated limit $1,000

CAPTURE

Policy requires human approval

refund-policy v17.3 · human approval required above $500

POLICY

Reviewer approves the action

Alice reviews the $720 refund and approves the proposed action

REVIEW

Approved tool call executes

stripe.refunds.create is called after the approval event

ACTION

Real-world outcome is recorded

Stripe reports the refund succeeded · re_demo_720

OUTCOME

Evidence is independently verifiable

All required evidence is present and the signed record verifies

PROOF

DECISION ENVELOPEdec_demo_720

IN PROGRESS

Evidence captured4 / 9

Agent identitysupport-agent-04

Delegated authorityrefund:create · $1,000

Model provenancesupport-reasoner

Prompt / contextsupport-v14

Policy provenancepending

Human oversightpending

External actionpending

Observed outcomepending

Cryptographic proofbuilding

Execution logs tell you what ran.LoopGrid preserves why it was allowed, who approved it and what happened next.

HOW LOOPGRID WORKS

Capture → seal → investigate → prove.

The evidence model is append-only. Reviews, actions, outcomes and replays become new signed events instead of rewriting the original decision.

Capture

Ingest the consequential decision through REST, Python/TypeScript SDKs, OpenTelemetry/OTLP or MCP.

Seal

Commit each evidence event to a workspace-isolated chain and sign it outside the agent's own trust boundary.

Investigate

Reconstruct what happened, inspect approvals and policy versions, and run counterfactual replay without mutating production history.

Prove

Export a portable evidence bundle and verify hashes, signatures and chain continuity offline with signer pinning.

Agent identity

Which agent, service version and deployment acted.

Authority

Who it acted for, with which scopes and limits.

Model context

Provider, model and relevant prompt/context provenance.

Policy

The exact policy ID and version evaluated at decision time.

Human oversight

Approvals, rejections and adjudications become signed history.

External action

The state-changing tool or operation the system executed.

Observed outcome

What the external system actually reports happened.

Cryptographic proof

Content commitment, chain link, signer identity and checkpoint evidence.

PORTABLE EVIDENCE

Trust that can leave the dashboard.

A customer, security team or investigator can receive an evidence bundle and independently verify it. The bundle can include disclosures or withhold them while preserving the signed commitment.

manifest.jsondecision.jsonevents.jsonlchain-witness.jsonlpublic-key.pemreport.html

Open the interactive verifier →

offline verifierloopgrid_verify.py

$ python verifier/loopgrid_verify.py evidence.zip

LOOPGRID EVIDENCE VERIFICATION

✓ VERIFIED

decision events7chain witnesses4signer matchtruefailures0

FIT INTO THE STACK YOU ALREADY RUN

One evidence layer across models, runtimes and tools.

Current LoopGrid integration paths cover the core agent stack. Additional provider and runtime adapters can be layered on without changing the evidence model.

Explore integration patterns →

SDK + API

RESTPythonTypeScript

Models / capture

OpenAIAnthropicLangGraph

Open protocols

OpenTelemetryOTLP/HTTPMCP

Verification / CI

GitHub ActionsOffline verifierSigner pinning

Next adapter targets: Gemini / Vertex AI, Azure OpenAI, AWS Bedrock, OpenAI Agents, Google ADK, Microsoft Agent Framework, CrewAI and PydanticAI. These are roadmap targets, not claims of completed production validation.

from loopgrid import LoopGrid

grid = LoopGrid(
    base_url="http://localhost:8000",
    api_key="lg_dev_…"
)

grid.record_decision(
    decision_type="customer_refund",
    privacy_mode="redacted",
    agent={"id": "support-agent-04"},
    proposed_action={
        "tool": "stripe.refunds.create",
        "amount": 720
    }
)

export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://127.0.0.1:8000/v1/traces
export OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=http/protobuf
export OTEL_EXPORTER_OTLP_TRACES_HEADERS="X-LoopGrid-Key=lg_live_…,X-LoopGrid-Workspace=default"

# v0.8.1 also accepts OTLP/HTTP JSON
# and optional Content-Encoding: gzip

POST /api/v1/mcp-proxy/billing
X-LoopGrid-Key: lg_dev_…

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "refund_customer",
    "arguments": {"amount": 720}
  }
}

- uses: actions/checkout@v7
- uses: loopgridio/loopgrid-evidence-verify@v1.0.0
  with:
    evidence: ./evidence/evidence.zip
    trusted-public-key: ./keys/loopgrid-production-public-key.pem

# CI fails if evidence verification fails.

PRIVACY + TRUST BOUNDARY

Evidence does not require centralizing every sensitive payload.

LoopGrid separates signed evidence from raw disclosures, so teams can choose how much data to retain while preserving the cryptographic commitment.

FULL

Encrypted disclosure

Raw payload can live in a separate AES-256-GCM vault while the ledger retains its cryptographic commitment.

REDACTED

Field commitments

Configured sensitive values become typed/hash commitments while the surrounding evidence remains readable.

PROOF-ONLY

Keep source data customer-side

Store only the commitment and evidence metadata. Original sensitive data can stay in the customer's environment.

Read the threat model →Read the integration guide →

SIGNINGEd25519 local · AWS KMS path

TIMESTAMPINGSigned checkpoints · optional RFC 3161

ACCESSScoped service keys + human RBAC

RETENTIONErase disclosures without rewriting history

THE “DON'T JUST SIGN WHAT THE AGENT SAYS” BOUNDARY

For higher-risk actions, capture the downstream action and observed result at a boundary the agent does not control.

Out-of-band capture is the low-friction default. When the evidence claim depends on whether a tool actually changed external state, use the MCP / action / outcome path so the record can include what the downstream system reports happened — not only the agent's assertion.

WHO LOOPGRID IS FOR

Start where an AI agent can change something consequential.

The strongest first workflows are not generic chatbots. They are agents that move money, change records, create permissions, communicate with customers or invoke tools that alter real system state.

MORTGAGE + CREDIT AI

Loan, income and risk workflows

Preserve which AI system influenced a workflow, the policy/context at the time, human oversight and the resulting action or outcome.

Explore mortgage & credit →

FINANCIAL + RISK ACTION

Refunds, claims, fraud and transactions

Preserve authority, threshold policy, approval lineage, external action and the outcome reported by the downstream system.

Explore financial & risk →

ENTERPRISE AGENTS

Records, permissions and back-office actions

Preserve delegated authority, rules, human intervention and the state change that followed.

Explore enterprise agents →

VOICE + CUSTOMER OPS

Calls that trigger real business actions

Connect the conversation to identity/authorization, policy, tool execution and the system-confirmed outcome without replacing native call logs.

Explore voice & customer ops →

DESIGN PARTNER PROGRAM

Bring one consequential agent workflow.

We will instrument the evidence path, run a real scenario, verify the evidence independently and define what a production deployment would require in your environment.

See the Design Partner program Review the decision flow

One state-changing workflow
REST / SDK / OTLP / MCP integration path
Policy + human review evidence
External action + observed outcome
Portable evidence bundle + offline verification
Production-readiness gap review

START WITH ONE REAL WORKFLOW

Make one consequential agent decision provable end to end.

Bring a production or pilot workflow. We will map the evidence path, capture the decision lifecycle and show what a hardened deployment would require in your environment.

Start with one workflow View pricing structure

FAQ

What technical buyers ask first.

Is LoopGrid another observability platform?

No. LoopGrid can ingest observability signals, but its primary job is to preserve decision accountability as portable evidence: identity, authority, policy, oversight, action, outcome and cryptographic proof.

Does LoopGrid replace n8n, Zapier, LangGraph, LangSmith or Fiddler?

No. Workflow runtimes execute the process; observability and control products explain or govern it. LoopGrid is designed to sit alongside them and preserve the evidence of the consequential decision.

Does LoopGrid make our system legally compliant?

No. Evidence integrity can support governance, audit and regulatory workflows, but it is not by itself a legal compliance determination.

Do we have to send every prompt or customer payload to LoopGrid?

No. FULL, REDACTED and PROOF-ONLY modes let a team store encrypted disclosures, hashed field commitments or only the cryptographic commitment.

Can a third party verify a record without LoopGrid access?

Yes. Portable evidence bundles can be verified offline, and signer pinning lets a recipient verify the signer against an out-of-band trusted identity.

What is validated today, and what remains per-pilot?

v0.8.1 is the current Design Partner patch release. PostgreSQL/Docker persistence, restart recovery, signing-key persistence, chain continuity and OTLP/HTTP protobuf + JSON ingestion are validated on the current baseline. Deployment-specific controls such as managed signing, timestamp trust and scaling are reviewed with each environment. See the Security page for the technical readiness matrix and threat model.