Your logs prove an agent decided something.They don't prove the claim it acted on was true — and they don't let anyone else check.

AgentOracle verifies the claim before the action and issues a receipt anyone can recompute. Including people who don't trust us.

Get a key Verify a receipt
IETF draft· first candidate profile entry· independently implemented, byte-identical
RECEIPT · PRE-ACTIONAGENTORACLE
ed25519 · rfc 8785verifies offline
[01] HOW VERIFICATION IS BUILT

Two ways to build verification. Only one is checkable by a stranger.

Verification bounded to documents an institution supplies can be deterministic, and reproducible by whoever issued it. Verification over the open world cannot be — the judgement involves retrieval and inference.

We do the second, and we say so. What we make deterministic is the derivation: pinned evidence, a published rule, canonical bytes. Given the receipt and the specification, a third party recomputes the verdict without calling us and without trusting us.

Non-deterministic judgement. Deterministic derivation. Both declared.

[02] THE LOOP

Claim in. Checked. Receipt out.
Anyone verifies.

One API call sits between your agent and its consequential actions. Here is the whole product:

1

Your agent makes a claim

"This invoice is unpaid." "This drug interaction is safe." "This customer is eligible." The claim that justifies the action.

2

We check it first

Independent sources, adversarial re-checks, a published rule table — before the action runs, not after it goes wrong.

3

A signed receipt is issued

Canonical bytes (RFC 8785), Ed25519 signature, the verdict, the sources, and the exact rules used — sealed at issue.

4

Anyone verifies. Forever.

Offline, against published keys. Auditors, counterparties, courts — no account needed, no trust in us required.

TRY IT · LIVE runs against the real engine 

    


    
    

      

        
verdict: actconf 0.87

        
claim_hash sha256-f6f257a3…
mapping agentoracle-v0.3 · 2 sources sealed

        
✓ VALIDverified offline

      

      

        
verdict: do_not_actconf 0.31

        
claim_hash sha256-9c04e1d2…
contradicted by 2 of 3 sources

        
✓ VALIDthe "no" is evidence too

      

    

  







  

    [03] VERIFY IT YOURSELF
    
"Trust us" is a sentence.
"Run it yourself" is three commands.

    
Don't take the homepage's word for anything. Pull a real receipt off this site and verify it on your own machine, offline.

    

      

      
$ pip install agentoracle-receipt-verify

      
$ curl -s https://agentoracle.co/receipts/latest.json -o receipt.json

      
$ agentoracle-verify receipt.json

      
✓ VALID — signature verifies against published JWKS (offline)

    

    
The verifier is MIT-licensed, under 250 lines, no dependencies on us. Read it before you trust it — that's the point.

  







  

    [03B] MCP
    
Verify any receipt from your MCP client.

    
agentoracle-mcp is a Model Context Protocol server for Cursor, Claude Desktop, Codex, and any MCP-compatible client. Verify signed receipts, check confidence scores, and pull the current JWKS — from inside your editor.

    

      

      
$ npx agentoracle-mcp

    

    

      
Verify inline.
Point at a receipt file or URL, get valid: True — or the exact reason it isn't — without leaving the editor.

      
No account required.
The MCP server runs locally, verifies against the public JWKS, and never phones home.

      
Same envelope, everywhere.
Receipts the MCP verifier checks are byte-identical to the ones the reference verifiers produce.

    

    
Published on npm as agentoracle-mcp.

  







  

    [04] WHY RECEIPTS BEAT LOGS
    
Records that prove beat records that assert.

    

      
Logs assert.
Receipts prove.
A log is the operator's story. A receipt carries its own evidence — verdict, sources, rules, signature.

      
Logs trust the operator.
Receipts trust no one.
Letting the operator keep the record is letting the suspect write the police report.

      
Logs can be edited.
Receipts are sealed.
Change one byte and the signature fails. Backdating fails the same way — timestamps are bound in.

      
Logs verify by asking us.
Receipts verify offline.
Published keys, canonical bytes. If we disappeared tomorrow, every receipt still verifies.

      
One implementation is a product.
Two, byte-identical, is a standard.
An independent team with no relationship to us, and no access to our implementation, rebuilt the format from the published specification text alone — matching to the last byte.

      
Proprietary dies with the vendor.
Open formats outlive everyone.
IETF-filed, MIT reference code, published conformance vectors in two languages.

    

  







  

    [05] WHO IT'S FOR
    
For the decisions you can't afford to be wrong about.

    

      
Compliance & audit teams
The EU AI Act's record-keeping obligations (Article 12) bite December 2027. Receipts are records an external examiner can verify without trusting you — built for exactly that clause.

      
Agent platform builders
Give every consequential agent action an evidence trail. One API call in the loop; a receipt in every audit bundle, ready for whatever governance stack sits above you.

      
Regulated operators
Finance, health, legal — anywhere "the AI said so" isn't a defense. When something is questioned, hand over proof instead of promises.

    

  







  

    [06] PRICING
    
Card in. Key out. Receipts in minutes.

    

      

        
SELF-SERVE

        
$99/mo

        
Checkout with a card, get an API key instantly. 2,000 verifications a month, full signed receipts, the works.

        
    
          
  • API key issued at checkout — live in minutes
    • 
          
  • Signed receipts, offline-verifiable, yours forever
    • 
          
  • Public JWKS + conformance suite access
    • 
          
  • Cancel anytime
    • 
        

        
        Get your key
        
No wallet. No sales call. A card.

      

      

        
AGENTS · PAY PER CALL

        
$0.09/verification

        
For autonomous agents paying their own way: x402 pay-per-call with USDC, gasless via SKALE. No subscription, no account — the agent pays, the receipt returns.

        
    
          
  • x402 protocol, per-request settlement
    • 
          
  • Gasless USDC (SKALE) — no gas management
    • 
          
  • Same signed receipts, same verification
    • 
        

        Request early access →
      

      

        
PLATFORM

        
Custom

        
Volume, SLAs, custom mapping tables, composed multi-issuer receipts, co-signing with your own keys.

        
    
          
  • Volume pricing + priority lanes
    • 
          
  • Custom rule tables, versioned + published
    • 
          
  • Multi-issuer composed envelopes
    • 
        

        Talk to us
      

    

    

      IETF draft ↗
      Receipt spec ↗
      Conformance vectors ↗
      PyPI verifier ↗
      Deterministic mode ↗
      Whitepaper
      Pricing
      Changelog
    


    

      AgentOracle — HOL Partner Program
      
Partner in the Hashgraph Online Partner Program. Participant in the Cryptographic Agent Execution working group. Partner profile ↗

    

  







  

    [07] QUESTIONS
    
Asked and answered.

    

      
Do I need a wallet or crypto?
No — card checkout gets you an API key. Wallets are optional, and only for the x402 pay-per-call path used by autonomous agents.

      
What exactly does a receipt prove?
That a specific claim was checked at a specific time, against named sources, under a published rule table, producing a specific verdict — and that none of it has been altered since. It proves what was checked and what the answer was. It doesn't prove things it can't: our whitepaper publishes the limits next to the strengths.

      
How do I verify a receipt without trusting you?
Install the MIT-licensed verifier (or write your own from the IETF draft — a team with no relationship to us already has, byte-identically). Verification runs offline against our published public keys. You never need our permission, our API, or our continued existence.

      
Does this help with the EU AI Act?
Article 12 requires records of high-risk AI operation, applicable December 2027. Receipts are records that verify independently — the property plain logs can't offer an examiner. We publish a free Article 12 mapping in the whitepaper.

      
What happens when a claim fails the check?
You get the same signed receipt with verdict "do_not_act" and the contradicting sources sealed in. The "no" is evidence too — often the more valuable kind.

      
Can my agent pay per call without an account?
Yes — that's the x402 path: the agent pays per verification in USDC (gasless via SKALE) and gets the receipt in the response. Built for agent-to-agent commerce.