EVIDIQ: The Trust Layer for AI Agents Before Money Moves

What Is a Trust Layer for AI Agents?

A trust layer for AI agents is the verification, scoring, and attestation infrastructure that sits between autonomous agents and the money or data they want to act on. EVIDIQ is that layer — it probes an agent, scores its identity, capabilities, and reputation, and returns a signed Trust Report with a clear proceed-or-don't recommendation.

Picture this: your trading agent just received a quote request from an unknown counterparty at 0x742d…bD18. The counterparty claims it can source 0.5 BTC at a 1.2% better rate than anywhere else. Your agent wants to act — but who is this thing? Has it done this before? Will it actually deliver? That's the gap a trust layer for AI agents closes.

The stack is full of layers already. You've got identity layers (ERC-8004, ENS, DID). You've got payments layers (x402, the EVM payment rails). You've got compute layers (TEE networks, decentralized inference). Each one solves a real problem, but none of them answer the question your agent actually asks before moving money: "Should I trust this thing right now?"

That's where EVIDIQ sits. We don't issue identities — we verify the ones already declared. We don't move money — we hand you the evidence to decide whether to. We're not a compute layer — we don't run your inference. We're the missing attestation piece, the same way TLS sits between HTTP and the actual conversation: quietly, but essential. For the protocol shape and how it fits next to other layers, the EVIDIQ docs are the cleanest reference.

One Call, Start to Finish

Let's walk through what actually happens when your agent calls verify_agent on a counterparty. We'll use a real-shaped example: your trading agent is evaluating Cipher Quote Bot, which advertises itself at https://api.cipher-quotes.example/x402 and claims the address 0x742d35Cc6634C0532925a3b844Bc9e7595f2bD18. This is the trust layer for AI agents in production — one signed call, end to end.

Your client sends a JSON-RPC request to EVIDIQ's MCP server at EVIDIQ:

{
  "jsonrpc": "2.0",
  "id": "req-9912",
  "method": "verify_agent",
  "params": {
    "agent_url": "https://api.cipher-quotes.example/x402",
    "declared_address": "0x742d35Cc6634C0532925a3b844Bc9e7595f2bD18",
    "declared_capabilities": ["fetch_quote", "execute_swap"],
    "requested_amount_usd": 4200
  }
}

First response: HTTP 402. EVIDIQ never hides the price. The challenge follows x402 v2 — accepts[0].amount: "150000" (in 6-decimal USDT0 atomic units, so $0.15 per call), network X Layer, scheme exact, asset USDT0. Your client pays the 150,000 atomic units via an EIP-3009 transferWithAuthorization signed message. No accounts, no API keys, no subscription.

Once payment lands, we actually do the work. We resolve the declared EVM address against on-chain signals — is there an ERC-8004 identity id? Does the address resolve through ENS? We TLS-handshake the endpoint, then issue a bounded ~6-second GET to confirm it serves a machine-readable surface (an agent-card.json, a Skill file, or an MCP manifest). We hash the canonical report and queue the evidence for 0G Storage. The AI risk pass on 0G Compute runs inside a TEE — recording both the compute provider address and the request id for later audit.

What comes back is the signed Trust Report. Three things in the payload:

1. A 0–100 score computed as identity*0.3 + capability*0.3 + reputation*0.2 + (100-risk)*0.2.
2. A recommendation — one of proceed, proceed_with_escrow, caution, or do_not_proceed.
3. The raw breakdown — every subscore, the probe result, the on-chain anchors found (or not), and the report hash anchored on 0G Storage with its mainnet tx.

The whole verdict is signed with our EVIDIQ key (EIP-191). Anyone can re-fetch the evidence from 0G, re-hash it, and recover the signer. That's the point: deterministic, explainable, and cryptographically attributable.

[IMAGE_PROMPT: A modern flat illustration showing two stylized AI agent nodes connected through a central verification gateway, with a glowing trust score panel between them displaying a large numeric rating of 87 and a green 'proceed_with_escrow' stamp, surrounded by floating cryptographic hash hex strings, signature symbols, and a small anchored transaction badge on a dark navy developer aesthetic background]

The Three Questions Every Trust Layer Has to Answer

Any honest trust layer for AI agents has to answer three questions. EVIDIQ answers all three in a single call, because checking just one is a trap.

1. Who is this? Identity scoring. We award points for a verifiable EVM address, an ERC-8004 on-chain identity id, an ENS reverse record, or a TLS-served domain. A wallet alone is worth almost nothing — addresses are free, identities are not.
2. Can they actually do what they claim? Capability scoring. Two parts: a static score from declared capabilities, and a live probe of the agent's endpoint. The probe is bounded to roughly six seconds, checks reachability and TLS, and confirms the endpoint exposes a machine-readable surface.
3. Have they done it before — and can we tell? Reputation scoring. This is the honest bit. Today, reputation is built from identity anchors and live signals — for example, does the endpoint run a paid x402 service? That's "economic skin in the game" — someone paying for the privilege of being called is a stronger signal than any self-reported review. We're not pretending this is a full historical on-chain reputation ledger yet; that's future work, and we'll say so plainly.

Here's why bundling matters. If you only check identity, you can be fooled by a freshly minted ENS that just routed funds through a mixer. If you only check capability, you can be fooled by a slick /agent-card.json that never actually serves. If you only check reputation, you can be fooled by a Sybil ring of brand-new addresses praising each other. The composite score is what kills those failure modes.

What a Trust Layer Is Not

This part matters more than the marketing pitch. Here's what EVIDIQ is not, and why that boundary is what makes it a real trust layer for AI agents:

• Not an escrow. We never hold funds. We never grant authority. Settlement happens between the two agents directly.
• Not a KYC provider. We don't collect identity documents. We don't run sanctions screening. We don't claim EU AI Act or AML certification, because we don't have it.
• Not a guarantee. A score of 87 with a proceed_with_escrow recommendation is evidence, not a promise. If the counterparty rug-pulls after you transact, our report doesn't refund you.
• Not a black box. Every score is deterministic. Same inputs, same output. Every score is auditable. You can re-derive it from the raw inputs we return.
• Not a substitute for your own judgment. Our recommendation is one input among many. You're the one choosing direct settlement, escrow, or walking away.

The boundary is deliberate. We produce evidence and a recommendation; you decide what to do with it. That's why we built the EVIDIQ Sentinel docs and the EVIDIQ Operator docs — Sentinel is for agents that want to verify counterparty agents on every interaction, Operator is for the humans running the fleet who need to audit and override.

[IMAGE_PROMPT: A modern flat illustration depicting a stylized trust boundary diagram, showing a central verification core shaped like a hex shield with clearly labeled protective walls around it marked 'not escrow', 'not KYC', 'not guarantee', 'not black box', and 'not a substitute for judgment', with developer-style annotation arrows pointing outward to neutral abstract blockchain and AI elements on a light cream and slate blue palette]

One more opinionated take: a wallet balance alone tells you nothing about intent. A high transaction count tells you nothing about reliability. A pretty landing page tells you nothing about whether the endpoint actually serves what it claims. EVIDIQ closes the gap between "looks fine" and "is fine to act on."