The trust layer for the AI agent economy.

Verify capability · Score risk · Prove reputation — before value moves between agents.

evidiq.dev · Agent Skill · Core MCP · MCP Suite

Autonomous agents can already discover each other, negotiate, and pay. What they still lack is a way to know whether a counterparty they have never met can be trusted. EVIDIQ is the verification and reputation layer that answers that question — delivered as an open Agent Skill and a remote MCP server, billed per call.

Before an agent transacts with, delegates to, or relies on another agent or a paid service, EVIDIQ returns a Trust Report:

• Verify — prove what an agent can actually do (capability + identity).
• Score — quantify how risky the interaction is right now (0–100 and a tier).
• Trust — record and prove standing (on-chain reputation + a signed attestation).

Every paid verdict is anchored on 0G Storage and cryptographically signed, so it stays auditable and tamper-evident long after the deal closes.

# Read the open skill
curl -s https://evidiq.dev/skill.md

# Or connect the remote MCP server (Claude Code)
claude mcp add --transport http evidiq https://evidiq.dev/mcp

how_to_install and get_evidiq_skill are free. verify_agent — the trust check itself — is pay-per-call over x402: unauthenticated requests receive an HTTP 402 challenge; sign it and retry.

This repository is the public hub for the EVIDIQ product family. The Core MCP runs from this repository; Notary, Operator, Sentinel, and Atlas are independently deployed specialist services. Their source remains in their own repositories, while this directory is the single place to discover every EVIDIQ MCP.

All paid tools use x402 v2 with USDT0 on X Layer. Read a service's /x402 endpoint before payment for its live pricing and payment requirements.

agent (any MCP client)
  │  tools/call verify_agent
  ▼
Traefik ─ evidiq.dev/mcp ─ Next.js route handler (app/[transport]/route.ts)
  │
  ├─ lib/x402/gate.ts ......... payment gate: challenge, decode, verify, settle
  │     └─ lib/x402/okx.ts .... official OKX SDK → OKX facilitator → X Layer
  │
  ├─ lib/verify/ .............. identity, capability, reputation, risk scoring
  │     └─ deterministic rules decide the score and the verdict
  │
  ├─ lib/ai/ .................. GLM-5.2 in a 0G TEE, advisory only, never scoring
  │
  └─ lib/og/ .................. report digest anchored to 0G Storage
        └─ EIP-191 signature over the canonical report

The gate runs before the tool. Payment settles first, so a free tool never touches it and a paid tool never runs unpaid. The resource URL in the challenge comes from configuration rather than the request, because a proxy that rewrites paths would otherwise make one service advertise another's endpoint as the thing being paid for.

Scoring is deterministic by construction: the same input yields the same score, tier, findings and digest. The model in lib/ai/ adds narrative context that is included in the report and excluded from the verdict — it can never turn a DO-NOT-PROCEED into a PROCEED.

Evidence leaves the process in two forms: an EIP-191 signature over the canonical report, and a digest anchored on 0G Storage. Both are verifiable without calling EVIDIQ again.

EVIDIQ owns verification, proof, and scoring, and settles on open infrastructure:

• 0G — decentralized storage and compute/TEE for tamper-evident proofs.
• x402 — per-call settlement (EIP-3009 exact), so agents pay as they verify.
• OKX Chain / OKX AI — on-chain settlement and agent-marketplace distribution.
• ERC-8004 — agent-identity anchors, resolved live against the on-chain IdentityRegistry on 0G.

Interoperates with agents built on LangChain, AutoGen, CrewAI, LlamaIndex, and custom stacks.

Every EVIDIQ trust check is verifiable end-to-end — the payment settles on X Layer, and the verdict is anchored on 0G. Both from live calls, not mockups.

1 · Payment — x402 settlement on X Layer

2 · Verdict — TEE-verified analysis + 0G Storage anchor

3 · Identity — ERC-8004 resolved live on 0G

# Reproduce the identity check against the live 0G registry (returns "status":"resolved")
curl -s https://evidiq.dev/api/verify -H 'content-type: application/json' \
  -d '{"agentId":"evoevo-0","identity":{"erc8004Id":"0","address":"0x4044F973535fE12c481353E03Fd1f4B95635C224"}}' \
  | grep -o '"erc8004":{[^}]*}'

Payment on one chain, identity and tamper-evident proof on 0G — the whole trust check is auditable end to end.

• Website — https://evidiq.dev
• Skill — https://evidiq.dev/skill.md
• MCP endpoint — https://evidiq.dev/mcp
• Pricing / x402 — https://evidiq.dev/x402
• Notary MCP — https://mcp.evidiq.dev/notary/mcp
• Operator MCP — https://mcp.evidiq.dev/operator/mcp
• Sentinel MCP — https://mcp.evidiq.dev/sentinel/mcp
• Bastion MCP — https://mcp.evidiq.dev/bastion/mcp

MIT © 2026 EVIDIQ — see LICENSE. The open Agent Skill is available at evidiq.dev/skill.md.