GENESIS

ProofRelay

Verification receipts for paid agent actions

Trust AI actions before they trigger payments, approvals, or transaction workflows.

ProofRelay gives agents, APIs, and MCP servers a simple checkpoint result — pass, fail, needs review, or skipped — backed by public-safe receipt evidence.

Start with one paid action. ProofRelay verifies the public-safe evidence around the request, entitlement, response, and replay result before anyone relies on it.

Verify one action — $5 Copy MCP setup See verification flow

Pre-action

Decision context captured before reliance

Tamper-evident

Recompute hashes instead of trusting a stored flag

Public-ready

Share receipt IDs, bundle hashes, and verifier outputs

Causal

Link parent and child receipts across agent handoffs

Start with one paid action.

The fastest path is not a broad platform demo. It is one verified paid action, one clear receipt, and one reason the buyer would pay again.

+ Provably untampered receipts — not just logs
+ Invisible pass/fail/review checkpoints for high-value agent/API/MCP actions
+ Inputs, policy, payment context, and response hashes sealed together
+ Public discovery and deterministic verification outputs for counterparties
+ Outcome-led AI reliance checkpoints before high-value workflow actions

Why now: companies are adding AI agents and copilots faster than they are adding reliance infrastructure. ProofRelay gives teams a checkpoint layer before expensive actions move forward.

Invisible integration

Wrap the checkpoint. Show the status. Keep the proof.

Developers do not need to learn evidence-bundle internals first. ProofRelay can sit behind selected agent, API, and MCP actions, returning a simple status while preserving non-confidential receipt evidence for audits, disputes, and case studies.

Add invisible checkpoints

pass

Evidence bundle verified for the selected checkpoint.

fail

Hash, signature, count, receipt-order, or chain verification failed.

needs_review

Human approval is required for money movement, outreach, deployment, or regulated claims.

skipped

Low-risk local work does not need ProofRelay overhead.

Try it now playground

See a checkpoint decision without signing up.

Paste public-safe metadata only. This local demo mirrors the buyer mental model: missing authority routes to review, complete evidence can pass, and tamper signals fail.

Bundle metadata

Result

{
  "status": "needs_review",
  "reason": "Authority metadata is missing."
}

Why not just use AI?

AI generates outputs. ProofRelay verifies reliance evidence.

LLMs can summarize, recommend, and call tools. ProofRelay answers a different question: does the submitted evidence meet the checkpoint requirements before a payment, approval, transaction, or workflow action moves forward?

Architecture before docs

Client

Submits an action, bundle, or workflow result.

Agent / API / MCP server

Produces output and public-safe metadata.

ProofRelay checkpoint

Verifies receipts, hashes, authority, and replay context.

Decision engine

Returns pass, needs_review, fail, or skipped.

Comparison

Manual review and logs do not create reliance checkpoints.

Read the AI reliance case →

Feature	Manual review	Audit logs	ProofRelay
Automated checkpointing	No	No	Yes
MCP-aware verification	No	No	Yes
Evidence bundle validation	No	Partial	Yes
Pass/fail/review decisions	No	No	Yes
Human review routing	Manual	No	Yes

Real estate proof-pack use case

Closing verification before transaction workflows move forward.

• Agent assembles a closing or diligence package.
• ProofRelay checks bundle integrity, receipt chain, and authority metadata.
• Missing signatures, stale documents, or weak authority route to human review.
• Pass/fail/review result becomes a public-safe verification record.

Published signals

Live enough to test. Narrow enough to trust.

Public MCP endpoint

https://mcp.genesisre.io/mcp

26 public-safe tools

Read-only verifier and recommendation surface

Smithery listing

Verified discovery path for MCP builders

AWS Marketplace path

Fulfillment and entitlement checks are implemented

Tool count note: the hosted server-card is the source of truth. Some marketplaces may cache or display a subset of tools. Call proofrelay.get_verifier_status to confirm the current public tool surface.

Revenue path of least resistance

Pick the smallest paid proof that matches your workflow.

Start self-serve when you have a bundle. Request intake when you need GENESIS to map a workflow into receipts, verifier outputs, and a paid ProofRelay integration path.

Open paid verification intake

Start now

Single verification

Agent builders validating one paid MCP/API result.

One entitlement-backed bundle verification and replay check.

Start this path

Build an integration

Developer bundle

$49

Builders testing an MCP/API integration before buying a team pack.

Request developer setup while multi-credit checkout is finalized.

Request developer bundle

Map a real workflow

Assessment

$2,500

Buyers with a real workflow, audit risk, or dispute exposure.

One workflow mapped into receipts, verifier outputs, and next steps.

Start this path

Today: action without proof

• Agent pays or calls a tool
• Service returns an answer
• Logs are fragmented across systems
• A dispute depends on operator trust

With ProofRelay: sealed receipt trail

• Request, policy, payment, entitlement, and response evidence are hashed
• Verifier recomputes integrity checks from the submitted bundle
• Counterparties receive a deterministic pass/fail decision and hash
• Sensitive files, credentials, and private logs stay out of the bundle

ProofRelay payment options

Choose the smallest ProofRelay path that matches the evidence you have today. Enterprise pilots and managed support live in the full GENESIS catalog.

See all GENESIS offers →

one_time

GENESIS ProofRelay Single Verification

Pay for one non-confidential ProofRelay bundle verification through the AWS/Strands entitlement flow.

Open payment catalog

one_time

GENESIS ProofRelay Developer Bundle

$49

Start Stripe Checkout for ten ProofRelay verification credits to test an integration before buying the $500 pack.

Open payment catalog

one_time

GENESIS ProofRelay Assessment

$2,500

Pay, then provide one workflow to map into receipts and verifier outputs.

Open Stripe Checkout

What happens after checkout?

GENESIS confirms the workflow, verifies the submitted public-safe bundle, and returns a proof envelope or verification result. For developer and workflow paths, GENESIS provisions credits or support according to the selected offer and the current entitlement status.

What is an evidence bundle?

A compact JSON proof pack containing receipt IDs, canonical event hashes, signatures, hash-chain links, timestamps, service metadata, and minimized non-sensitive payload hashes.

How do I call it?

Agents can request a Stripe-backed entitlement via https://genesisre.io/api/revenue/aws-agent/proofrelay/checkout-token, then redeem a paid bundle at https://genesisre.io/api/revenue/aws-agent/proofrelay/paid/verify/bundle.

Price model

Stripe-backed options start at $5 for a single verification. The $49 developer bundle is a request path until multi-credit checkout is live; the assessment maps real workflows into proof envelopes.

Copy / paste MCP setup

Connect ProofRelay where agent builders already work.

Use ProofRelay as a read-only verifier and checkpoint router. Do not send private prompts, source code, credentials, or raw logs.

Open full MCP setup page →Open Registry and badges →

Smithery CLI

Fastest path for marketplace users.

npx -y smithery mcp add genesis/proof-relay
npx -y smithery tool list proof-relay
npx -y smithery tool call proof-relay proofrelay.get_verifier_status '{}'

Claude / generic MCP JSON

Use streamable HTTP and keep the public tool allowlist narrow.

{
  "mcpServers": {
    "proofrelay": {
      "type": "streamable-http",
      "url": "https://mcp.genesisre.io/mcp"
    }
  }
}

Cursor, Windsurf, Codex, Replit

Point agent IDEs at the same MCP URL; do not upload private logs.

MCP_URL=https://mcp.genesisre.io/mcp
TOOLS=proofrelay.get_verifier_status,proofrelay.recommend_checkpoint,proofrelay.verify_bundle
BOUNDARY="non-confidential evidence only"

01 / Execute

The agent performs or requests a paid action and captures minimized request, policy, payment, entitlement, and response evidence.

02 / Seal

ProofRelay hashes the compact bundle and checks hash-chain, timestamp, signature, and replay assumptions without storing secrets.

03 / Verify

Any authorized verifier can submit the bundle and receive a deterministic pass/fail result plus a verification hash.

04 / Prove

The receipt can be shared as a decision record for customer support, audit, governance, dispute review, and agent-to-agent handoff.

Who uses this first?

• AI agent builders using paid tools, data, APIs, and MCP servers
• API/SaaS teams selling metered access to autonomous agents
• AI governance, risk, and compliance teams
• LLM and agent-security reviewers
• Vendor-risk, due-diligence, and compliance consultants
• Real estate, title, escrow, lending, and closing platforms
• Stripe, AWS AgentCore, MCP, x402, and marketplace operators

What does it verify?

• Canonical bundle-hash consistency
• Receipt event hashes and HMAC signatures
• Receipt hash-chain continuity
• Payment-token replay protection when production charging is enabled
• Agent request, payment challenge, entitlement, and service-response evidence shape
• Deterministic pass/fail verification response shape

Verifier boundary

Public enough to trust. Narrow enough to be safe.

The best ProofRelay experience is explicit about both the proof and the boundary: users get a deterministic receipt decision without asking GENESIS to become a processor, wallet, oracle, or log sink.

+ Verifies bundle shape, receipt ordering, hash-chain continuity, signature signals, replay signals, and payment or entitlement evidence when supplied
+ Does not verify real-world truth, legal/title status, payment custody, source-code correctness, customer files, secrets, or raw logs

Decision receipt examples

Case-study receipts buyers immediately understand

ProofRelay.app makes the use case concrete with realistic receipts. GENESIS now does the same while keeping the examples clearly illustrative and non-confidential.

Real estate closing package

Wire instruction change · title/escrow review

A closing agent, lender, or transaction coordinator submits public-safe hashes for title, payoff, wire, signer authority, and lender-condition evidence before a closing workflow advances.

Verifier: title officer · escrow team · lender closer

SAMPLE RECEIPT

title_commitment_versionhash recorded

wire_instruction_changeauthority metadata missing

lender_condition_checklist5/6 present

decision_resultNEEDS_REVIEW

Healthcare treasury

$2.4M wire authorization · SOX review

An AI treasury agent evaluates vendor approval, OFAC screening, daily limits, and authorization thresholds before a wire instruction is trusted.

Verifier: SOX auditor · internal audit · reinsurer

SAMPLE RECEIPT

decision_resultEXECUTE

conditions_evaluated4/4 PASS

bundle_hashsha256:7b4f…19ac

verification_policystrict_signature_required

Insurance claims

$1.8M claim approval · bad-faith defense

A claims agent records policy form, fraud screen, payment deadline, and approval rationale before a claimant or regulator relies on the result.

Verifier: plaintiff counsel · regulator · special master

SAMPLE RECEIPT

decision_resultAPPROVE

prompt_payment_checkPASS

receipt_chainparent/child linked

verification_hashsha256:0fd2…8b91

Agent commerce

Paid MCP/API result · entitlement replay check

A buyer agent pays through Stripe, calls a paid tool, and later verifies entitlement, request, response, and receipt continuity without exposing secrets.

Verifier: buyer agent · platform operator · dispute reviewer

SAMPLE RECEIPT

payment_railStripe Checkout

entitlement_hashsha256:91ab…c274

no_charge_attemptedsynthetic tokens blocked

service_boundaryevidence integrity only

Where ProofRelay fits

AWS AgentCore

Runs agents, manages payment sessions, wallets, limits, and observability. ProofRelay can verify minimized evidence bundles produced after paid AgentCore tool/API activity.

Stripe Checkout

Primary GENESIS payment rail for ProofRelay offers. Stripe payment confirmation creates entitlement evidence for paid verification workflows.

x402-XRPL

Uses HTTP 402 payment challenges with settlement references. ProofRelay maps request, challenge, payment proof, facilitator receipt, response, and replay result into PREP evidence.

Marketplace directories

Discovery surfaces point builders to ProofRelay MCP, PREP profiles, Stripe entitlements, and x402-XRPL evidence; deprecated rails stay compatibility-only.

What it does not verify

• Real-world truth or external facts
• Legal, tax, title, mortgage, securities, escrow, or custody status
• AI model safety, prompt correctness, or source-code correctness
• Confidential raw logs, customer files, credentials, or private keys

Live API structure

Execute & verify

Agents submit compact proof bundles. ProofRelay returns a verifier decision, hash, and policy details that can be replayed in audits, disputes, incident reviews, and agent-to-agent handoffs.

Open machine-readable spec →

REQUEST — paid verification

POST https://genesisre.io/api/revenue/aws-agent/proofrelay/paid/verify/bundle
Content-Type: application/json
x-genesis-entitlement-token: <stripe-backed-entitlement-token>

{
  "v": 1,
  "bundle_hash": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
  "created_ts_ms": 1780000000000,
  "service": "agent-commerce-demo",
  "count": 2,
  "receipt_ids": ["rcpt_001", "rcpt_002"],
  "events": [
    {
      "event_hash": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
      "receipt_id": "rcpt_001"
    },
    {
      "event_hash": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
      "receipt_id": "rcpt_002"
    }
  ]
}

RESPONSE — verifier decision

{
  "ok": true,
  "paid": true,
  "provider": "stripe",
  "payment_protocol": "stripe_checkout_entitlement",
  "simple_status": "pass",
  "checks": {
    "bundle_shape": "pass",
    "entitlement_or_payment": "pass",
    "verifier": "pass",
    "replay_policy": "pass",
    "proof_envelope": "pass"
  },
  "proof_envelope_hash": "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
  "proof_envelope": {
    "schema": "genesis.proofrelay.proof_envelope.v1",
    "rail": "stripe",
    "envelope_hash": "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
  }
}

The repository includes a valid sample bundle, invalid chain example, JSON Schema, Postman collection, and technical demo notes underconfigs/revenue and docs/revenue.

Buyer FAQ

Pricing and usage questions agent builders ask first

What should I buy first?

Buy the $5 single verification when you have one paid MCP/API result or bundle replay check. Request the $49 developer bundle when you are integrating ProofRelay into one workflow. Use the assessment when a real workflow needs mapping.

Do I need to send private logs or customer files?

No. ProofRelay uses minimized, non-confidential evidence bundles: hashes, receipt IDs, signatures, policy digests, and safe metadata.

Does ProofRelay process payments?

No. Stripe handles checkout. ProofRelay verifies the evidence trail and entitlement use around the paid action.

Does the public MCP charge me?

No. The public MCP is a free, read-only builder and verifier surface. Paid reviews, implementation help, private deployments, and enterprise support route separately through Stripe or GENESIS intake.

Should every agent action use ProofRelay?

No. Use it selectively when an action becomes worth proving: paid APIs, autonomous jobs, delegated agents, external services, human approvals, or audit-sensitive workflows.

What is the fastest MCP setup path?

Use Smithery with genesis/proof-relay, then call get_verifier_status before submitting any bundle.

When should I request an assessment?

Use the assessment when a workflow involves audits, refunds, SLAs, compliance review, counterparty reliance, or dispute replay.

Start sealing paid-agent decisions today.

Buy one $5 verification when you have a bundle or paid MCP/API result. Request the developer bundle when you are ready to integrate ProofRelay inside one workflow.

Buy one $5 verification Request developer bundle Open full checkout catalog Request paid workflow intake Run replay demo View on Smithery

Prefer an MCP registry listing? ProofRelay is published at Smithery.