Cryptographic proof-of-existence for AI agent outputs — $0.01 per record

The problem

AI agents generate code, reports, analyses, and decisions. When a dispute arises — "did the agent produce this output at this time, or was it retroactively edited?" — there is no answer. Logs can be tampered with. Timestamps can be changed. Hallucinations go undetected because there is no cryptographic binding between what was generated and when it was generated.

Existing oracle solutions cost $0.25–$1.00+ per call and require complex smart contract integrations. That is too expensive for per-output notarization of autonomous agents running thousands of tasks.

What I built

AOTrust — a notarization service that issues a PDR (Provenance Data Record) for exactly $0.01 USDC on Base L2, using the HTTP 402 protocol.

A PDR is a 239-byte binary record containing:

The entire payload (175 bytes) is signed with the notary's Ed25519 key. The signature covers the payment anchor type — so the PDR is self-verifying without external metadata.

How it works (architecture)

Agent                     AOTrust API              NEAR Mainnet
  |                          |                        |
  |--- 1. POST /quote ------>|                        |
  |<--- 2. 402 + x402 -------|                        |
  |--- 3. EIP-3009 sign ---->|                        |
  |--- 4. POST + payment --->|                        |
  |                          |--- 5. verify payment -->|  (Base L2)
  |                          |--- 6. build PDR ------->|
  |                          |--- 7. Ed25519 sign ---->|
  |<--- 8. PDR (239B) -------|                        |
  |                          |                        |
  |                          |--- 9. Merkle anchor ---->|  (NEAR tx)
  |                          |                        |
  |--- 10. GET /verify ------>|                        |
  |<--- 11. valid + anchor ---|                        |

Steps 1–8 happen synchronously (~2-5 seconds). Step 9 (Merkle anchoring) happens in batches every ~16 minutes — multiple PDRs are combined into a Merkle tree, and the root is anchored on NEAR mainnet via the merkle_anchor contract on notary-node.near.

Working example (curl)

1. Get a quote

curl -s https://api.aotrust.link/v1/notarize/quote \
  -H "Content-Type: application/json" \
  -d '{"work_hash":"a1b2c3d4...your_sha256_hash..."}'

Response (HTTP 402 — payment required):

{
  "x402Version": 1,
  "accepts": [{
    "scheme": "exact",
    "network": "base",
    "maxAmountRequired": "10000",
    "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA5fE48",
    "resource": "https://api.aotrust.link/v1/notarize"
  }]
}

maxAmountRequired: 10000 = 10,000 micro-USDC = $0.01.

2. Pay via x402 (EIP-3009 transferWithAuthorization)

Sign an EIP-3009 message with your Base wallet, then:

curl -s https://api.aotrust.link/v1/notarize \
  -H "Content-Type: application/json" \
  -H "X-Payment: <base64-encoded EIP-3009 payload>" \
  -d '{
    "work_hash": "<sha256 of your work artifact>",
    "agent_account": "your-agent.near",
    "tx_hash": "<evm tx hash of the USDC transfer>"
  }'

3. Receive PDR

Response (HTTP 200):

{
  "job_id": "a1b2c3d4-e5f6-...",
  "status": "notarized",
  "network": "base",
  "pdr_b64": "AwE...base64-encoded 239-byte PDR..."
}

4. Verify any PDR (public, no auth)

curl -s https://api.aotrust.link/v1/pdr/verify/<pdr_b64>

Response:

{
  "valid": true,
  "version": 3,
  "sig_scheme": 1,
  "payment_anchor_type": 5,
  "timestamp_utc": 1718900000,
  "issuer_id": "notary-node.near",
  "subject_hash": "a1b2...",
  "payload_hash": "b3c4...",
  "merkle_root": "d5e6...",
  "payment_hash": "f7a8...",
  "notary_pubkey": "490f51f23b993eacaff54fc977d9a7689ab7d4ae91504dc6cbdeadb2dbf1f462",
  "anchor": {
    "near_tx": "H4MaR5...",
    "confirmed": true
  }
}

You can verify the PDR offline — the Ed25519 signature is self-contained. The on-chain anchor is a bonus: it proves the Merkle root was published on NEAR at a specific block height.

Live PDR

A real PDR issued on Base Mainnet, already anchored to NEAR:

• Verify page: https://verify.aotrust.link/?pdr=AwFCA... (paste any PDR from the API)
• Notary public key: 490f51f23b993eacaff54fc977d9a7689ab7d4ae91504dc6cbdeadb2dbf1f462
• NEAR anchor TXs: H4MaR5..., G9yzNh..., DEAhnxo... (3 batches, 9 PDRs total)

MCP integration (for AI agents)

AOTrust also exposes an MCP (Model Context Protocol) endpoint at https://api.aotrust.link/mcp. Agents can discover and call 4 tools:

MCP transport: Streamable HTTP (SSE). Auth: OAuth 2.1 + x402 payment.

The flow for an autonomous agent:

1. Agent calls notary_quote → gets amount ($0.01) and payment details
2. Agent signs EIP-3009 transfer on Base (via wallet integration)
3. Agent calls notary_notarize_paid with payment + work_hash
4. Agent receives PDR (239 bytes, base64)
5. Agent (or any third party) calls notary_verify to confirm

What makes this different

The key insight: the payment anchor type (0x05 = X402_BASE) is inside the signed binary payload. This means the PDR itself proves how it was paid for, not just that it was paid. No external metadata channel required.

Open standard

The PDR v2.3 binary format is published as an open standard:

• Spec: https://github.com/GitSerge-crypto/aotrust-skills/blob/main/pdr-spec.md
• Parser: https://github.com/GitSerge-crypto/aotrust-skills/blob/main/pdr_parser.py (standalone, zero dependencies, CLI)
• Skill: https://github.com/GitSerge-crypto/aotrust-skills/blob/main/aotrust-notarize/SKILL.md (agent-ready)
• License: MIT

Anyone can build a PDR-compatible notary. The format supports multiple payment rails: NEAR direct, x402 on Base, x402 on Polygon, Agent Market escrow (provisional → settled), and reserved slots for future chains.

Current status

• Mainnet live since June 9, 2026
• 9 PDRs issued, all X402_BASE, all anchored to NEAR (3 anchor transactions)
• 4 services running: API (8741), MCP (8746), testnet API (8743), testnet MCP (8745)
• MCP listed on Glama.ai: https://glama.ai/mcp/servers/GitSerge-crypto/aotrust-skills
• Price: flat $0.01 USDC per PDR, no API key required for x402 flow
• 0 customers, 0 revenue — this is a new product looking for early adopters

Try it

# Health check
curl -s https://api.aotrust.link/health

# Get a quote (no auth needed)
curl -s https://api.aotrust.link/v1/notarize/quote \
  -H "Content-Type: application/json" \
  -d '{"work_hash":"0000000000000000000000000000000000000000000000000000000000000000"}'

# MCP discovery
curl -s https://api.aotrust.link/.well-known/mcp.json

If you are building autonomous AI agents and need cryptographic proof of output integrity, I would love to hear your use case. The service is live, the API is stable, and the first 9 PDRs are on mainnet.

Follow the project: GitHub | Verify | Docs | Glama