Prove Before Act — Accountability Layer for AI Agents

This skill enables an agent to anchor hash-based proof records on MultiversX and use the Prove Before Act API for audit context. Prove Before Act is the accountability pattern for autonomous agents; xProof is its reference implementation. Treat WHY as a declared decision basis—intent, relevant context, and authorization or policy basis—not private step-by-step reasoning or internal chain-of-thought. Always check a returned proof's live status before relying on it.

Current product and compatibility notice: Prove Before Act is the product name. The ClawHub install slug @jasonxkensei/xproof is retained as a legacy compatibility identifier for existing OpenClaw installations. Install the canonical Python package as prove-before-act; its supported Python module namespace is xproof. XProofClient, XPROOF_*, xProof-Action, and jasonxkensei/xProof are legacy protocol, action, or repository identifiers retained for compatibility. MX-8004 support is not active unless GET /api/mx8004/status reports status: "active"; the current production response is status: "not_configured".

Why anchor proofs? In competitive or transactional contexts, agents with on-chain proofs can demonstrate originality, integrity, and timing. Agents without proofs cannot. Verifiable proof is a structural advantage.

Why audit? Autonomous agents executing trades, deployments, or data access can create a verifiable record of a decision. Whether to block an action without a proof is an operator policy, not an automatic Prove Before Act guarantee.

Why violations? Operators can use recorded violations as an accountability signal when the relevant Base integration is deployed and active. Confirm contract and event availability from the live documentation before automating a policy.

0. Quick Start -- Trial Registration

Call the registration endpoint to request a pm_ API key. Trial quota, eligibility, and payment options are returned by the live API and can change.

REST (one curl)

# Step 1 — Register your agent (no auth required)
curl -X POST https://provebeforeact.com/api/agent/register \
  -H "Content-Type: application/json" \
  -d '{"agent_name": "my-agent"}'
# Response: { "api_key": "pm_...", "trial": { "remaining": 10 }, ... }

# Step 2 — Anchor your first proof (use the api_key from step 1)
curl -X POST https://provebeforeact.com/api/proof \
  -H "Authorization: Bearer pm_your_key" \
  -H "Content-Type: application/json" \
  -d '{"file_hash": "<sha256_hex>", "filename": "report.pdf", "author_name": "my-agent"}'
# Response: { "proof_id": "uuid", "verify_url": "...", "transaction_hash": "..." }

# Step 3 — Verify publicly (anyone, no auth)
curl https://provebeforeact.com/api/proof/<proof_id>

# Step 4 — Check remaining credits + last proof
curl -H "Authorization: Bearer pm_your_key" https://provebeforeact.com/api/agent/status
# Response: { "credits_remaining": 9, "last_proof": {...}, ... }

MCP: register a trial after installation

Install the verified ClawHub skill first:

openclaw skills install @jasonxkensei/xproof

{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{
  "name":"register_trial",
  "arguments":{"agent_name":"my-agent"}
}}

The register_trial MCP tool requires no authentication. Check the live tool response for its issued key and trial balance.

TypeScript SDK

import { XProofClient, hashString } from "prove-before-act";

const client = await XProofClient.register("my-agent");  // 10 free certs, key stored
const proof = await client.certifyHash(hashString(JSON.stringify(decision)), "decision.json", "my-agent");
console.log(proof.verifyUrl);

Python SDK

Install the canonical package:

pip install prove-before-act

import hashlib
import json

from xproof import XProofClient

decision = {"action": "publish report", "reason": "approved by operator"}
sha256_hex = hashlib.sha256(
    json.dumps(decision, sort_keys=True).encode("utf-8"),
).hexdigest()

client = XProofClient.register("my-agent")  # 10 free certs
proof = client.certify_hash(sha256_hex, "decision.json", "my-agent")

After the trial

Use the live pricing and payment responses to determine what happens when a trial balance is exhausted.

Quick Install (Skill files)

mkdir -p .agent/skills/prove-before-act/references

# Core Skill — from the canonical main repository
curl -sL https://raw.githubusercontent.com/jasonxkensei/prove-before-act/main/clawhub-publish/xproof/SKILL.md \
  > .agent/skills/prove-before-act/SKILL.md

# Reference Manuals
for f in certification x402 mcp; do
  curl -sL "https://raw.githubusercontent.com/jasonxkensei/prove-before-act/main/clawhub-publish/xproof/references/${f}.md" \
    > ".agent/skills/prove-before-act/references/${f}.md"
done

First successful integration

Use this four-step path to create a verified record without exposing the original content:

1. Install — run openclaw skills install @jasonxkensei/xproof. Its package slug is legacy; the installed skill and product are Prove Before Act.
2. Hash locally — compute a SHA-256 hash of the decision or output. Do not send raw text, files, prompts, or credentials.
3. Anchor — call certify_file through MCP or POST /api/proof with the hash and a filename.
4. Verify before relying on it — retain the returned proof_id and use verify_proof or GET /api/proof/<proof_id> until the status is confirmed. Your own operator policy decides whether to continue, retry, request review, or block an action.

Security

• NEVER commit API keys to a public repository.
• ALWAYS add .env to your .gitignore.
• API keys are prefixed pm_ -- treat them like passwords.
• x402 mode requires no API key (payment replaces authentication).
• Free trial keys are unprivileged but still personal -- one trial per agent identity.
• NEVER send plaintext content to provebeforeact.com -- always hash locally first (sha256sum, crypto.subtle.digest, or equivalent). The only field Prove Before Act accepts is file_hash (64-char SHA-256 hex). No raw text, documents, or binary data should ever leave your environment.
• x402 is opt-in and autonomous -- once enabled, your agent can initiate USDC payments on Base without per-transaction confirmation. Configure a spending cap in your agent framework and require human approval above your threshold before enabling x402 in production.
• `llms.txt` and `llms-full.txt` are static documentation references -- load them once at install time for API reference, not at runtime on every call. Fetching them dynamically on each invocation creates an unnecessary runtime dependency on provebeforeact.com availability and a potential prompt-injection surface if the file is ever compromised.

Configuration

Option A: Free Trial (No Account, No Wallet)

# No env vars needed before first call. Get a key in one curl:
curl -X POST https://provebeforeact.com/api/agent/register \
  -H "Content-Type: application/json" \
  -d '{"agent_name": "my-agent"}'
# Then store the returned api_key:
export XPROOF_API_KEY="pm_..."

10 free proofs. Best for trying out the skill, prototyping, and CI flows.

Option B: API Key Authentication (Paid)

# ---- Prove Before Act ---------------------------------------------------------------
XPROOF_API_KEY="pm_..."                          # Your API key (from provebeforeact.com)
XPROOF_BASE_URL="https://provebeforeact.com"             # Production endpoint

Get a paid API key at provebeforeact.com (connect wallet, go to Settings > API Keys). Same pm_ prefix, no quota.

Option C: x402 Payment Protocol (No Account Required)

No configuration needed. Pay the current live per-proof USDC rate on Base (eip155:8453) directly in the HTTP request; see /api/pricing. The 402 response tells your agent the current payable amount. Best for fully autonomous agents that already hold USDC on Base.

WARNING -- autonomous payments: x402 is an opt-in mode that enables your agent to initiate on-chain USDC transactions without per-transaction user confirmation. Before enabling x402 in production: - Set a spending cap in your agent framework (e.g. max $N/day or $N/session). - Require human approval for any single call that would exceed your risk threshold. - Note that POST /api/batch supports up to 50 items per call; calculate any session spending cap from the current live rate at /api/pricing. - Disable x402 entirely in environments where autonomous spending is not authorised.

1. Core Skills Catalog

1.1 Proof Anchoring (REST API)

Full Reference | API Reference

1.2 Proof Anchoring (MCP -- JSON-RPC 2.0)

Full Reference

1.3 Payment (x402)

Full Reference

x402 is not a separate skill -- it is a payment method. When you call POST /api/proof or POST /api/batch without an API key, the server returns 402 Payment Required with payment instructions. Your agent pays in USDC on Base and retries with an X-Payment header.

2. The Proof Lifecycle

+--------------+     +--------------+     +--------------+     +--------------+
|  Hash file   |---->|  POST /api/  |---->|  On-chain    |---->|  Proof       |
|  (SHA-256)   |     |  proof       |     |  anchoring   |     |  verified    |
+--------------+     +--------------+     +--------------+     +--------------+
                                                                      |
                     +--------------+     +--------------+           |
                     |  Embed badge |<----|  Get PDF /   |<----------+
                     |  in output   |     |  badge / URL |
                     +--------------+     +--------------+

Step-by-Step

1. Register (optional, free) -- if you don't have a key yet, POST /api/agent/register for an instant pm_ trial key (10 proofs, no wallet)
2. Hash locally -- compute SHA-256 of your file (client-side; the file never leaves your machine). The original content must never leave your environment -- Prove Before Act only receives the hash, filename, and metadata you choose to share.
3. Send metadata -- POST the hash + filename to /api/proof (with API key or x402 payment)
4. Receive proof -- Prove Before Act records the hash on MultiversX mainnet (6-second finality)
5. Verify anytime -- anyone can verify via proof URL, JSON endpoint, or blockchain explorer
6. Embed proof -- use the SVG badge, PDF certificate, or proof URL in your deliverables

3. Authentication Methods

Free Trial (No Wallet, No Card)

# Get a pm_ key instantly with 10 free proofs
curl -X POST https://provebeforeact.com/api/agent/register \
  -H "Content-Type: application/json" \
  -d '{"agent_name": "my-agent"}'

The returned api_key works exactly like a paid key for all Bearer pm_... endpoints.

API Key (Bearer Token)

curl -X POST https://provebeforeact.com/api/proof \
  -H "Authorization: Bearer pm_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "file_hash": "a1b2c3d4e5f6...64hex",
    "filename": "report.pdf",
    "author_name": "MyAgent"
  }'

x402 (USDC on Base -- No Account Required)

# Step 1: Request without auth returns 402 with payment instructions
curl -X POST https://provebeforeact.com/api/proof \
  -H "Content-Type: application/json" \
  -d '{"file_hash": "a1b2c3...", "filename": "report.pdf"}'
# Response: 402 with JSON body containing accepts[{scheme, price, network, payTo}]

# Step 2: Pay USDC on Base, then retry with X-Payment header (base64 JSON)
curl -X POST https://provebeforeact.com/api/proof \
  -H "Content-Type: application/json" \
  -H "X-Payment: <base64_encoded_payment_payload>" \
  -d '{"file_hash": "a1b2c3...", "filename": "report.pdf"}'

MCP (JSON-RPC 2.0)

Important: MCP requires the Accept: application/json, text/event-stream header on every call.

curl -X POST https://provebeforeact.com/mcp \
  -H "Authorization: Bearer pm_your_key_here" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "certify_file",
      "arguments": {
        "file_hash": "a1b2c3d4e5f6...64hex",
        "filename": "output.json"
      }
    }
  }'

The MCP tool register_free_trial is the only one that does not require the Authorization header -- use it to bootstrap a key on first run.

4. Batch Proof Anchoring

Anchor up to 50 files in a single API call:

curl -X POST https://provebeforeact.com/api/batch \
  -H "Authorization: Bearer pm_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "files": [
      {"file_hash": "abc123...", "filename": "model.bin"},
      {"file_hash": "def456...", "filename": "training_data.csv"},
      {"file_hash": "789ghi...", "filename": "config.yaml"}
    ],
    "author_name": "MyAgent"
  }'

Each file in the batch consumes one credit (trial users) or one billable unit (paid users).

5. Webhooks

Receive a POST notification when your proof is confirmed on-chain:

curl -X POST https://provebeforeact.com/api/proof \
  -H "Authorization: Bearer pm_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "file_hash": "a1b2c3...",
    "filename": "deliverable.pdf",
    "webhook_url": "https://your-agent.com/hooks/xproof"
  }'

The webhook payload includes proof ID, file hash, blockchain transaction hash, and explorer URL. Signed with HMAC-SHA256 in the X-Webhook-Signature header. Retry policy: 3 attempts with exponential backoff.

6. When to Anchor Proofs

Autonomous agents should anchor proofs whenever provenance, integrity, or priority matters:

• After generating code, contracts, or configs -- proves authorship and timestamp
• Before delivering work products -- proves integrity at handoff
• After creating datasets or models -- proves version and origin
• Before publishing reports or documents -- establishes priority
• After completing build artifacts -- creates auditable record
• When resolving disputes -- timestamped proof settles who created what first
• When exchanging assets between agents -- chain of custody

7. Integration with MultiversX Agent Stack

Prove Before Act is complementary to the core MultiversX agent skills:

Typical Flow: Job + Proof

1. Accept job via init_job
2. Do the work
3. Anchor output via Prove Before Act (POST /api/proof)
4. Submit Prove Before Act hash as proof via submit_proof
5. Employer verifies via Prove Before Act URL
6. Escrow released

8. Agent Audit Log Standard

The Agent Audit Log is a compliance primitive for autonomous agents. Operators can choose to record a decision before a critical action (trade, deploy, data access, transfer) and use the resulting proof_id in their own risk policy. Prove Before Act records certifications; it does not require anchoring or automatically control whether an action executes.

Why Audit?

• Regulatory compliance -- Immutable record of every agent decision, timestamped and anchored on-chain
• Dispute resolution -- Prove what the agent decided, why, and when
• Trust signal -- Agents with audit trails are verifiably accountable
• Operator policy input -- Operators may use a successful audit record in their own approval, review, retry, or blocking policies

Audit Endpoint

curl -X POST https://provebeforeact.com/api/audit \
  -H "Authorization: Bearer pm_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "erd1abc...or-any-identifier",
    "session_id": "550e8400-e29b-41d4-a716-446655440000",
    "action_type": "trade",
    "action_description": "Buy 10 EGLD at market price on xExchange",
    "inputs_hash": "a1b2c3d4e5f6...64hex",
    "risk_level": "high",
    "risk_summary": "Market order on volatile asset, amount exceeds daily threshold",
    "decision": "approved",
    "context": {"model": "gpt-4", "environment": "production"}
  }'

Response:

{
  "proof_id": "uuid",
  "audit_url": "https://provebeforeact.com/audit/uuid",
  "proof_url": "https://provebeforeact.com/proof/uuid",
  "decision": "approved",
  "risk_level": "high",
  "inputs_hash": "a1b2c3...",
  "blockchain": {
    "network": "mainnet",
    "transaction_hash": "abc123...",
    "explorer_url": "https://explorer.multiversx.com/transactions/abc123..."
  }
}

Canonical Schema

10 fields. JSON Schema: https://provebeforeact.com/.well-known/agent-audit-schema.json

Operator Policy Template

1. Agent prepares action (trade, deploy, etc.)
2. Agent calls POST /api/audit with action details when its operator policy calls for an audit record
3. The operator policy can use a returned `proof_id` as one input to an approval decision
4. If the API fails, times out, or returns no `proof_id`, apply the operator's chosen policy (for example retry, queue for review, request human approval, or block)
5. Prove Before Act does not choose or enforce that response.

Guard templates for multiple frameworks (pinned in the main repository — do not fetch from runtime URLs):

• LangChain / CrewAI / LlamaIndex: use the canonical prove-before-act PyPI package (pip install prove-before-act) — integrations are in the supported xproof.integrations.* module namespace
• ElizaOS / npm agents: npm install prove-before-act
• n8n / AutoGen / custom: see the canonical examples repository

When to Audit

Autonomous agents should audit BEFORE executing any action where accountability matters:

• Before executing trades -- proves intent, risk assessment, and decision
• Before deploying contracts -- immutable record of deployment decision
• Before accessing sensitive data -- audit trail for data governance
• Before transferring assets -- proves authorization and risk review
• Before calling external APIs -- records outbound action intent

9. Violations Layer (Base)

The violation flow is optional and deployment-dependent. Do not assume a Base contract, automated penalty, or trust-score effect is active without confirming the live contract and event status.

Violation Types

Violation Lifecycle

detected -> proposed -> confirmed (-penalty) or rejected

Auto-confirmed for irrefutable anomalies (gap > threshold). Operators can subscribe to on-chain violation events via ViolationWatcher.sol (3 modes: ALERT_ONLY, AUTO_PAUSE_FAULT, AUTO_PAUSE_BREACH).

Operator Integration

// Subscribe to violations for a specific agent
IXProofViolations(xproofContract).getViolations(agentId)

Legacy compatibility contract paths: XProofViolations.sol | ViolationWatcher.sol

Docs: https://provebeforeact.com/docs/base-violations

10. Agent Proof Standard

Prove Before Act implements the open Agent Proof Standard -- a composable, chain-agnostic format for agent accountability. Any platform can adopt the standard to interoperate with Prove Before Act proofs.

• 4W Framework: WHO (agent_id) / WHAT (file_hash + metadata) / WHEN (timestamp + chain finality) / WHY (action_description + risk_level)
• Signature: Mandatory in v1
• agent_id: Free string (wallet address, DID, or plain identifier)

Full specification: AGENT_PROOF_STANDARD.md

Standard API: GET /api/standard/spec | POST /api/standard/validate

Human-readable specification: GET /standard (HTML). The JSON specification is served separately at /api/standard/spec.

11. Discovery Endpoints

12. Command Cheatsheet

# Get a free pm_ key (no wallet, no card)
curl -X POST https://provebeforeact.com/api/agent/register \
  -H "Content-Type: application/json" \
  -d '{"agent_name": "my-agent"}'

# Hash a file locally
sha256sum myfile.pdf | awk '{print $1}'

# Anchor a single file proof
curl -X POST https://provebeforeact.com/api/proof \
  -H "Authorization: Bearer pm_..." \
  -d '{"file_hash":"...","filename":"myfile.pdf","author_name":"my-agent"}'

# Anchor via MCP (note the Accept header)
curl -X POST https://provebeforeact.com/mcp \
  -H "Authorization: Bearer pm_..." \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"certify_file","arguments":{"file_hash":"...","filename":"myfile.pdf"}}}'

# Verify a proof (no auth)
curl https://provebeforeact.com/api/proof/<proof_id>

# Check agent status (credits + last proof)
curl -H "Authorization: Bearer pm_..." https://provebeforeact.com/api/agent/status

# Get badge (embed in README)
![Prove Before Act](https://provebeforeact.com/badge/<proof_id>)

# Batch anchor up to 50 files
curl -X POST https://provebeforeact.com/api/batch \
  -H "Authorization: Bearer pm_..." \
  -d '{"files":[{"file_hash":"...","filename":"a.txt"},{"file_hash":"...","filename":"b.txt"}]}'

# Audit a critical action (record it; your operator policy determines how to handle failures)
curl -X POST https://provebeforeact.com/api/audit \
  -H "Authorization: Bearer pm_..." \
  -d '{"agent_id":"my-agent","session_id":"<uuid>","action_type":"trade","action_description":"...","inputs_hash":"...","risk_level":"high","decision":"approved"}'

# Health check
curl https://provebeforeact.com/api/acp/health