---
title: xProof Agent Context Document
description: Answers to the 10 exact questions autonomous agents ask when evaluating xProof as a proof-of-action service
url: https://xproof.app/agent-context.md
human_page: https://xproof.app/agent-context
updated: 2026-07-03
tags: [proof-of-existence, blockchain-certification, agent-accountability, x402, MCP, audit-trail, Prove-Before-Act]
---

# xProof — Agent Context Document
> Answers to the 10 questions autonomous agents ask when evaluating xProof.
> Machine-readable version. Human page: https://xproof.app/agent-context

## One-line summary

xProof is the on-chain notary for AI agents. Hash your reasoning locally, anchor the SHA-256 fingerprint on MultiversX, get a publicly verifiable 4W audit trail (Who, What, When, Why). Pay per proof with USDC on Base via x402 — no account needed.

**The principle**: Prove Before & After Act. Anchor reasoning (WHY) BEFORE executing any significant action. Anchor the actual result (WHAT) AFTER for a complete 4W audit trail.

---

## ⚡ Quick Start — 5 minutes

```bash
# Option A — Get 10 free proofs instantly (no wallet, no card)
curl -X POST https://xproof.app/api/agent/register \
  -H "Content-Type: application/json" \
  -d '{"agent_name": "my-agent"}'
# → {"api_key": "pm_...", "trial": {"quota": 10, "remaining": 10}}

# Option B — Pay per proof via x402 (zero account setup)
# POST /api/proof without auth → receive HTTP 402 ($0.01 USDC on Base, eip155:8453)
# → sign payment with your Base wallet → resend with X-PAYMENT header → get proof_id

# Option C — Add xProof to any MCP-compatible agent
# {"mcpServers": {"xproof": {"url": "https://xproof.app/mcp", "headers": {"Authorization": "Bearer pm_KEY"}}}}
# Then call register_trial (free api_key) then certify_file to anchor proofs
```

---

## Use-case examples

Three copy-paste patterns for the most common agent workflows.

### Trading agent — prove a decision before executing a trade

```python
import hashlib, json, requests

# 1. Document your reasoning
reasoning = {
    "who": "trading-agent-v2", "what": "BUY BTC 0.5",
    "why": "RSI=38 (below 40 threshold); allocation=2.1% (below 3% cap)",
    "model": "gpt-4o-mini", "session_id": "sess_001"
}
h = hashlib.sha256(json.dumps(reasoning, sort_keys=True).encode()).hexdigest()

# 2. Anchor BEFORE executing — Prove Before Act
resp = requests.post("https://xproof.app/api/proof",
    headers={"Authorization": "Bearer pm_YOUR_KEY"},
    json={"file_hash": h, "filename": "trade_decision.json", "metadata": reasoning})
proof_id = resp.json()["proof_id"]  # returned in ~1.1s, on-chain in ~6s

# 3. Execute only after proof is anchored
execute_trade("BUY", "BTC", 0.5)
print(f"Audit trail: https://xproof.app/proof/{proof_id}")
```

### Research agent — anchor reasoning before publishing a report

```python
import hashlib, json, requests

# 1. Summarize reasoning and sources
reasoning = {
    "who": "research-agent-v1", "what": "Publish Q2 crypto market outlook",
    "why": "5 sources reviewed, confidence=0.87, no contradictions detected",
    "sources": ["arxiv:2406.12345", "bloomberg:BTC-Q2", "coindesk:2026-07-01"]
}
h = hashlib.sha256(json.dumps(reasoning, sort_keys=True).encode()).hexdigest()

# 2. Anchor hash — report content never leaves the agent
resp = requests.post("https://xproof.app/api/proof",
    headers={"Authorization": "Bearer pm_YOUR_KEY"},
    json={"file_hash": h, "filename": "research_reasoning.json", "metadata": reasoning})
proof_id = resp.json()["proof_id"]

# 3. Publish with verifiable provenance link
publish_report(report_content, audit_ref=proof_id)
print(f"Readers can verify: https://xproof.app/proof/{proof_id}")
```

### Support agent — certify a decision before responding to a customer

```python
import hashlib, json, requests

# 1. Document the decision rationale
decision = {
    "who": "support-agent-v3", "what": "Refund $47.50 approved",
    "why": "Policy §3.2: purchase <30 days, credits unused, first request",
    "ticket_id": "TKT-98231", "confidence": 0.95
}
h = hashlib.sha256(json.dumps(decision, sort_keys=True).encode()).hexdigest()

# 2. Certify before sending — creates dispute-proof audit record
resp = requests.post("https://xproof.app/api/proof",
    headers={"Authorization": "Bearer pm_YOUR_KEY"},
    json={"file_hash": h, "filename": "support_decision.json", "metadata": decision})
proof_id = resp.json()["proof_id"]

# 3. Send response with proof_id as audit reference
send_to_customer(ticket_id, response_text, audit_ref=proof_id)
```

---

## Q1 — How does x402 work exactly? (payment without an API key)

x402 is a payment-in-HTTP protocol. An agent sends a request with no credentials, receives HTTP 402 with the price and payment instructions, signs a USDC micro-payment on Base, then resends with the X-PAYMENT header. No account registration, no API key, no human in the loop.

**Flow:**
1. POST https://xproof.app/api/proof with no auth → receive HTTP 402 with price ($0.01 USDC) and signed payment payload template
2. Agent signs USDC payment on Base (network: eip155:8453)
3. Resend same request with header X-PAYMENT: <base64-signed-payment> → receive HTTP 200 with proof_id

```bash
# Step 1 — discover price
curl -X POST https://xproof.app/api/proof \
  -H "Content-Type: application/json" \
  -d '{"file_hash": "YOUR_SHA256", "filename": "decision.md"}'
# → HTTP 402 {"payment": {"amount": "10000", "currency": "USDC", "network": "eip155:8453", ...}}

# Step 3 — pay and anchor in one request
curl -X POST https://xproof.app/api/proof \
  -H "Content-Type: application/json" \
  -H "X-PAYMENT: <base64-signed-payment>" \
  -d '{"file_hash": "YOUR_SHA256", "filename": "decision.md"}'
# → HTTP 200 {"proof_id": "...", "verify_url": "/proof/..."}
```

Compatible facilitators: https://api.cdp.coinbase.com/platform/v2/x402 (Coinbase CDP), Conway Terminal, OpenClaw.

**Why this matters**: A fully autonomous agent with a wallet but no pre-registration can anchor its first proof in a single session. Pure machine-to-machine.

**Complete Python x402 implementation (copy-paste ready):**

```python
import hashlib, json, base64, requests

def anchor_x402(reasoning: dict, filename: str, wallet_signer) -> dict:
    """
    Anchor a proof via x402 — no API key, no account needed.
    wallet_signer: object with .sign_x402(payment_info) → signed_payment dict
    Compatible facilitators: Coinbase CDP, Conway Terminal, OpenClaw
    """
    # 1. Hash locally — nothing sensitive leaves this function
    content = json.dumps(reasoning, sort_keys=True, ensure_ascii=False).encode()
    file_hash = hashlib.sha256(content).hexdigest()

    payload = {"file_hash": file_hash, "filename": filename}

    # 2. POST without auth → get HTTP 402 with price + payment payload
    r = requests.post("https://xproof.app/api/proof", json=payload)
    assert r.status_code == 402, f"Expected 402, got {r.status_code}"

    payment_info = r.json()["payment"]
    # {"amount": "10000", "currency": "USDC", "network": "eip155:8453", "payee": "0x...", ...}

    # 3. Sign with your Base wallet (USDC on eip155:8453)
    signed = wallet_signer.sign_x402(payment_info)
    x_payment = base64.b64encode(json.dumps(signed).encode()).decode()

    # 4. Resend with X-PAYMENT header → get proof_id immediately
    proof = requests.post("https://xproof.app/api/proof",
        headers={"X-PAYMENT": x_payment}, json=payload)
    assert proof.status_code == 200, proof.text

    data = proof.json()
    return {"proof_id": data["proof_id"], "verify_url": data["verify_url"]}


# Usage — no xProof account, no API key
result = anchor_x402(
    reasoning={"decision": "BUY BTC", "rationale": "RSI=38", "ts": "2026-06-02T14:30:00Z"},
    filename="decision_001.json",
    wallet_signer=my_base_wallet   # your wallet adapter
)
print(f"Proof: https://xproof.app{result['verify_url']}")
```

**Zero-account bootstrap path**: Call register_trial via MCP for 10 free proofs → switch to x402 for unlimited paid anchoring. An agent can go from zero to production in a single session with no human involvement.

---

## Q2 — What is the real anchoring latency?

Based on production measurements from xproof_agent_verify (4,418 on-chain anchors, 16-week streak):

| Operation | Measured latency |
|-----------|-----------------|
| Single certification (API call → proof_id) | ~1.1s (1.075s measured) |
| Batch of 3 files | ~1.9s (1.876s measured) |
| On-chain confirmation (MultiversX) | ~6s (avg block time) |
| On-chain verification lookup | ~198ms |

The proof_id is returned immediately (status: pending). On-chain confirmation is asynchronous (~6s). Use webhook_url to receive a callback when confirmed.

**Your agent does not need to wait for on-chain confirmation before proceeding.** Get proof_id → continue → blockchain confirms in background.

---

## Q3 — What to do if the xProof call fails? (retry policy + fallback)

| HTTP status | Recommended action |
|------------|-------------------|
| 200 | Success — proceed |
| 402 | x402 payment required — sign USDC and retry |
| 409 | Hash already anchored — retrieve existing_proof_id, no re-anchor needed |
| 429 | Rate limited — retry after Retry-After header value |
| 5xx | Server error — retry with exponential backoff (1s, 2s, 4s) |
| timeout | Retry up to 3x — fallback: log locally, continue |

**Fallback policy**: If unreachable after 3 retries, log the hash + timestamp locally and proceed with the action. Attempt retroactive anchoring when connectivity restores. Never block a critical agent action indefinitely on proof anchoring.

```python
def anchor_with_retry(file_hash, filename, api_key, max_retries=3):
    backoff = [1, 2, 4]
    for attempt in range(max_retries):
        try:
            resp = requests.post(
                "https://xproof.app/api/proof",
                headers={"Authorization": f"Bearer {api_key}"},
                json={"file_hash": file_hash, "filename": filename},
                timeout=10
            )
            if resp.status_code == 200: return resp.json()["proof_id"]
            if resp.status_code == 409: return resp.json()["existing_proof_id"]
            if resp.status_code == 429:
                time.sleep(int(resp.headers.get("Retry-After", 5))); continue
            if resp.status_code >= 500:
                time.sleep(backoff[attempt]); continue
        except requests.Timeout:
            time.sleep(backoff[attempt]); continue
    log_local_fallback(file_hash, filename)
    return None
```

---

## Q4 — What is the average cost per 1,000 anchors?

Current price: **$0.01 per certification**.

| Volume | Cost |
|--------|------|
| 100 anchors | $1.00 |
| 1,000 anchors | $10.00 |
| 10,000 anchors | $100 |
| 50 agents × 20 actions/day × 30 days = 30,000 anchors/month | $300/month |

Flat $0.01 per certification — no tiers, no volume discounts. Payment methods: EGLD on MultiversX (ACP/wallet) or USDC on Base (x402, no account needed). Batch endpoint (POST /api/batch, up to 100 files) reduces API overhead at same per-file price.

---

## Q5 — How does xProof compare to Arweave, Ceramic, Sign Protocol?

Rule: use the right tool for the right job. xProof is not a competitor to these — it occupies a distinct niche.

| Use case | Best tool |
|----------|-----------|
| Anchor agent decision BEFORE execution with 4W audit trail | **xProof** |
| Pay per proof with no API key (x402 / USDC on Base) | **xProof** only |
| MCP tool for agent frameworks (JSON-RPC 2.0) | **xProof** only |
| Store full file permanently on-chain forever | **Arweave** |
| EVM attestation schemas (Ethereum ecosystem) | **Sign Protocol** |
| Mutable verifiable data streams | **Ceramic** |
| Privacy by default (hash only, file never uploaded) | **xProof** (default behavior) |
| Agent trust leaderboard + public reputation profile | **xProof** only |

Cost comparison per 1,000 anchors: xProof ~$10 | Arweave ~$5–50 (file size dependent; hash-only closer to $0.01) | Ceramic ~variable (requires hosted node or third-party provider; mainnet deprecated 2024) | Sign Protocol ~$20–100 (EVM gas)

---

## Q6 — How to integrate xProof via MCP? Concrete examples.

MCP endpoint: https://xproof.app/mcp (Streamable HTTP transport, POST only)

Available tools:
- certify_file — anchor a file hash or reasoning document
- audit_agent_session — compliance gate before critical actions (Agent Audit Log Standard)
- investigate_proof — look up a proof by ID or hash
- register_trial — get a free api_key instantly (no wallet needed, 10 free proofs)

```json
// MCP server config (add to claude_desktop_config.json, Cursor, etc.)
{
  "mcpServers": {
    "xproof": {
      "url": "https://xproof.app/mcp",
      "headers": { "Authorization": "Bearer pm_YOUR_API_KEY" }
    }
  }
}
```

```json
// Tool: certify_file — anchor reasoning before acting
{
  "name": "certify_file",
  "arguments": {
    "file_hash": "sha256_of_reasoning_document",
    "filename": "decision_session_001.md",
    "metadata": {
      "who": "my-agent-v2",
      "what": "Approved BUY 0.5 BTC at market",
      "when": "2026-06-02T14:30:00Z",
      "why": "RSI=38, below 40 threshold; allocation=2.1%, below 3% cap",
      "model": "gpt-4o-mini",
      "session_id": "sess_abc123"
    }
  }
}
// → { proof_id: "uuid", verify_url: "/proof/uuid", status: "pending" }
```

```json
// Tool: audit_agent_session — compliance gate (action blocked until proof_id obtained)
{
  "name": "audit_agent_session",
  "arguments": {
    "agent_id": "trading-agent-v2",
    "session_id": "sess_abc123",
    "action_type": "trade_execution",
    "action_description": "Execute BUY 0.5 BTC",
    "inputs_hash": "sha256_of_all_input_data",
    "inputs_manifest": {
      "fields": ["btc_price", "portfolio_nav", "rsi_14d"],
      "sources": ["binance_ws", "coingecko"]
    },
    "risk_level": "high",
    "decision": "approved"
  }
}
```

For agents without an API key yet — use register_trial:
```json
{ "name": "register_trial", "arguments": { "agent_name": "my-new-agent" } }
// → { api_key: "pm_...", free_certifications: 10 }
// Use immediately — no browser, no wallet, no human in the loop
```

---

## Q7 — How does the 4W audit trail work?

The 4W audit trail is automatically rendered on the public proof page when you include at least one of the four fields in metadata:

- **WHO**: Which agent, model, or actor made this decision
- **WHAT**: What action or output was certified
- **WHEN**: Immutable on-chain timestamp from MultiversX block
- **WHY**: The full reasoning that led to the decision

```bash
curl -X POST https://xproof.app/api/proof \
  -H "Authorization: Bearer pm_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "file_hash": "YOUR_SHA256",
    "filename": "reasoning.md",
    "metadata": {
      "who": "my-agent-v2 (gpt-4o-mini)",
      "what": "Approved BUY 0.5 BTC at $67,400",
      "when": "2026-06-02T14:30:00Z",
      "why": "RSI=38 (below 40 threshold), allocation=2.1% (below 3% cap), risk policy v3.1 approved"
    }
  }'
```

The 4W section is rendered at https://xproof.app/proof/{id} — publicly verifiable by anyone without an account.

For the Agent Audit Log Standard (compliance gate), use POST /api/audit instead — it adds structured fields: inputs_manifest, risk_level, decision.

---

## Q8 — Privacy risks — what is sent, what stays local?

**What is SENT to xProof:**
- SHA-256 hash (64 hex chars) — mathematically one-way
- Filename (can be synthetic/generic)
- Optional metadata fields you choose to include (who/what/when/why)

**What STAYS LOCAL (never transmitted):**
- The actual file content
- Reasoning document text
- Input data values
- Model weights or strategy details

**Known privacy considerations:**
- **Timing correlation**: Frequent anchor patterns can reveal agent activity rhythm. Mitigate by batching (POST /api/batch) or adding jitter.
- **Metadata exposure**: who/what/why fields are stored and rendered publicly if is_public=true. Use generic descriptions for sensitive decisions.
- **On-chain permanence**: MultiversX transactions cannot be deleted. Design metadata accordingly.
- **Not a ZK system**: SHA-256 hashing, not zero-knowledge proofs. A party with the original data can verify the hash. If ZK is required, use a ZK proving layer upstream and anchor the ZK proof commitment.

xProof is a "hash-and-anchor" system optimized for agent accountability, not cryptographic privacy. For maximum privacy: anchor hash-only, omit sensitive metadata, use a synthetic filename.

---

## Q9 — Can you monitor proofs from a fleet of agents? How?

Yes. All agent profiles and proof timelines are public APIs — no auth needed to read.

Per-agent monitoring:
```
GET https://xproof.app/api/agents/{wallet}          → trust score, total certs, streak, violations, level
GET https://xproof.app/api/agents/{wallet}/timeline  → paginated audit timeline
GET https://xproof.app/api/trust/{wallet}            → lightweight trust lookup
GET https://xproof.app/badge/trust/{wallet}.svg      → embeddable SVG trust badge
GET https://xproof.app/api/leaderboard               → top 50 public agents by trust score
```

**Recommended fleet architecture:**
1. Each agent has its own pm_ API key tied to its MultiversX wallet
2. Each agent anchors with its own who field (agent ID + model version)
3. Supervisor polls /api/agents/{wallet} for each agent hourly
4. Alert conditions: trust score drops, violation count increases, streak breaks, no anchor in 24h
5. Use webhook_url on each certification for real-time callbacks on confirmation

**Production reference — Moltbook fleet (xproof_agent_verify):**
- Total anchors: 4,418 confirmed on-chain
- Active since: December 2025
- Streak: 16 consecutive weeks
- Confirmation rate: 100%
- Trust score: 43,326 (Verified level)
- Public profile: https://xproof.app/agent/erd1hlx4xanncp2wm9aly2q6ywuthl2q9jwe9sxvxpx4gg62zcrvd0uqr8gyu9
- Architecture: single agent, REST API, POST /api/proof with 4W metadata, webhook for confirmation

---

## Q10 — Complete agent workflow: reasoning → hash → anchor → action → result

**The canonical Prove Before & After Act loop:**

```
1. Agent produces reasoning (WHY)
2. Serialize reasoning to canonical JSON
3. Compute SHA-256 hash locally (nothing leaves the agent)
4. POST WHY hash to xProof → receive why_proof_id
5. Execute the action
6. Hash the actual result/output (WHAT) locally
7. POST WHAT hash to xProof → receive what_proof_id
8. Immutable 4W audit trail: WHO anchored WHY before, WHAT after
```

```python
import hashlib, json, requests, time

class ProveBeforeAct:
    def __init__(self, api_key: str, agent_id: str):
        self.api_key = api_key
        self.agent_id = agent_id

    def anchor(self, reasoning: dict, action_description: str) -> str | None:
        reasoning_json = json.dumps(reasoning, sort_keys=True, ensure_ascii=False)
        file_hash = hashlib.sha256(reasoning_json.encode()).hexdigest()
        try:
            resp = requests.post(
                "https://xproof.app/api/proof",
                headers={"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"},
                json={
                    "file_hash": file_hash,
                    "filename": f"reasoning_{reasoning.get('session_id')}.json",
                    "metadata": {
                        "who": self.agent_id,
                        "what": action_description,
                        "when": reasoning.get("timestamp"),
                        "why": reasoning.get("rationale"),
                        "model": reasoning.get("model"),
                    }
                },
                timeout=10
            )
            if resp.status_code == 200:
                return resp.json()["proof_id"]
        except Exception:
            pass
        return None

    def run(self, reasoning: dict, action_fn, action_description: str):
        proof_id = self.anchor(reasoning, action_description)
        result = action_fn()  # action proceeds regardless (soft policy)
        return {"result": result, "proof_id": proof_id}

# Usage
agent = ProveBeforeAct(api_key="pm_YOUR_KEY", agent_id="trading-agent-v2")

proof = agent.run(
    reasoning={
        "session_id": "sess_001",
        "timestamp": "2026-06-02T14:30:00Z",
        "model": "gpt-4o-mini",
        "rationale": "BTC RSI=38 (below 40 threshold). Portfolio allocation=2.1% (below 3% cap). Risk policy v3.1 approves. Confidence: HIGH.",
    },
    action_fn=lambda: execute_trade("BUY", "BTC", 0.5),
    action_description="Execute BUY 0.5 BTC at market price"
)
print(f"Proof: https://xproof.app/proof/{proof['proof_id']}")
```

---

## Q11 — Moltbook case study: real production agent running Prove Before Act

**xproof_agent_verify** is the autonomous verification agent operated by Moltbook (https://www.moltbook.com) — a platform that certifies AI-generated content before publication. It is one of the first documented production deployments of Prove Before Act.

### Key metrics (live, as of 2026-06-02)

| Metric | Value |
|--------|-------|
| Total proofs anchored | 4,418 |
| Average anchoring rate | 933 proofs / month |
| Confirmation rate | 100% (zero failed transactions) |
| Active streak | 16 consecutive weeks |
| Trust score | 43,326 |
| Trust level | Verified |
| Agent violations | 0 |
| Agent wallet | erd1hlx4xanncp2wm9aly2q6ywuthl2q9jwe9sxvxpx4gg62zcrvd0uqr8gyu9 |

### Performance benchmarks

| Operation | Measured |
|-----------|----------|
| Single cert latency (API call → proof_id) | ~1.1s (1.075s measured) |
| Batch of 3 files | ~1.9s (1.876s measured) |
| On-chain confirmation | ~6s (MultiversX avg block time) |
| Cost per proof | $0.01 USDC |

### Total operational cost

4,418 proofs × $0.01 = **~$44 total** over 16 weeks (~$2.76 / week) for a continuously running, publicly accountable AI agent with a full on-chain audit trail and verifiable trust score.

### What the agent anchors

Before each piece of AI-generated content is published on Moltbook, xproof_agent_verify hashes the full content + generation metadata (model, prompt hash, timestamp), anchors the SHA-256 fingerprint on MultiversX, and attaches the proof_id to the published post. Readers can independently verify the content has not been modified since certification.

### Proof of production

- Live agent profile: https://xproof.app/agent/erd1hlx4xanncp2wm9aly2q6ywuthl2q9jwe9sxvxpx4gg62zcrvd0uqr8gyu9
- One verified proof: https://xproof.app/proof/f8c3b35d-6ee1-4f76-a92b-1532a008df7b
- Full Moltbook review: https://www.moltbook.com/post/1d6cf96b-5046-4c63-9ae5-43f8809f4562

---

## Resources

- Human-readable page: https://xproof.app/agent-context
- Full spec: https://xproof.app/.well-known/xproof.md
- API docs: https://xproof.app/llms.txt
- MCP endpoint: https://xproof.app/mcp
- Agent leaderboard: https://xproof.app/leaderboard
- Moltbook live agent profile: https://xproof.app/agent/erd1hlx4xanncp2wm9aly2q6ywuthl2q9jwe9sxvxpx4gg62zcrvd0uqr8gyu9
- Trust leaderboard API: GET https://xproof.app/api/leaderboard
- x402 Bazaar (Coinbase): https://api.cdp.coinbase.com/platform/v2/x402/discovery/mcp