Agent payments -- demo.pay.vauban.tech/agents
Watch an autonomous agent pay
Autonomous agents are starting to spend money on their own. When they do, the party on the other side needs a settlement receipt it can verify, that survives quantum attack, and that does not leak the buyer. x402 gives agents a payment protocol over HTTP, but it stops at the payment ; it has no proof-grade settlement receipt to hand back.
Vauban Pay adds that missing layer: a post-quantum STARK receipt, a privacy-preserving value rail on Starknet, and a verifiable credential for audit. Below are five demos where a real agent settles real value on Starknet Sepolia. Pick a demo and watch the run replay line by line. Every transaction links to Voyager so you can check it yourself.
Replay a verified run
Pick one of the five demos. The terminal replays that exact run from real recorded data: the 402, the on-chain STRK transfer, off-chain proof verification, the data served, and the demo-specific final step. Nothing is fetched live ; this is an in-browser replay of runs that already happened on Sepolia.
Off-chain verified today plus an on-chain commitment anchor (demo 05) ; full on-chain proof verification is the next milestone. STARK throughout ; never SNARK. Vauban Pay is the Starknet-first reference implementation of the chain-agnostic Vauban Claim Algebra (VPSF).
Download the claim, the proof and the run certificate
The replay above is not the only evidence. These are the artifacts the facilitator and the agent runtime produced on real runs: the claim the proof commits to, the proof itself, and the Ed25519 run certificate of the paying agent. All are real files, not screenshots.
canonical_receipt.json ; 537 bytes, plain JSON cairo_air::verify_cairo
against for the Baseline run. Transparent, post-quantum, no trusted setup.
payment_proof.json.gz ; 13,368,216 bytes uncompressed (~1.9 MB gzip) cairo_air::verify_cairo ; 692 ms off-chain verify, debug build ; measured, not estimated.
run-certificate.json ; 1.7 KB, plain JSON demo/x402-agent/REPLAY.md (build-from-source).
settlement-claim-strk20-mainnet.json ; 3.1 KB, plain JSON cargo test -p zkpay-types --test strk20_fixture recomputes the
binding_ref (JCS + SHA-256) against the committed value; the pool
transaction re-reads on-chain, read-only. Steps in demo/x402-agent/REPLAY.md.
These are static fixtures from the Baseline run (demo 01), not generated per visitor.
The facilitator that served the 200 above ran the same verify_cairo check
live, per request, on the proof attached to that specific settlement.
Try the 402 live
Everything above replays a recorded run. This does not: a real
zkpay-facilitator container answers behind
/x402/v1/quote, running the same cairo_air::verify_cairo
check on whatever proof you send it. It runs in baseline fixture mode, so the
expected receipt is fixed to the proof downloaded above ; send anything else and
you get a fresh 402, not a fake accept. Three commands,
no wallet, no agent runtime.
curl -i https://demo.pay.vauban.tech/x402/v1/quote402 Payment Required with the PAYMENT-REQUIRED
manifest header (base64url CBOR : circuit VKs, merchant pseudonym, price).
gunzip -k payment_proof.json.gzcurl -i -X POST --data-binary @payment_proof.json \
https://demo.pay.vauban.tech/x402/v1/quote200 OK with a PAYMENT-RESPONSE receipt header
once cairo_air::verify_cairo accepts the proof ; measured ~1s
including the network round trip for the 13 MB body.
Baseline fixture mode only for this endpoint : no --settle-tx,
--delegation, or on-chain RPC read at request time. The composed
on-chain-bound and agentic-delegation modes documented in
crates/zkpay-facilitator/README.md are not exposed here.
Watch the agent do it
This is a real terminal recording, not a script written for this page: the preste
vauban-payer agent completes the x402 flow on its own, then two
independent checks run against what it produced ; the Ed25519 run certificate, and
the STARK proof of delegation via zkpay-stark-verify. Pause it, scrub
it, copy any command straight out of the player ; it is text, not a video.
Read-only replay of an already-mined Sepolia transaction ; no transaction is emitted. Prefer a video? download the .mp4.
What is real, what is demo, what is not yet
These demos are Phase 1. Nothing below is dressed up. Here is the exact boundary between what runs for real, what is a demo binding, and what is still ahead on the roadmap.
- agent autonomy ; the payer agent decides and acts without a human in the loop
- STRK transfer on Starknet Sepolia ; a real on-chain value movement
- STARK proof generation ; 13.4 MB Stwo Circle STARK M31 artifact
- off-chain verify_cairo per request ; the proof is checked on every settlement
- wire receipt + verifiable credential ; emitted in x402 V2 format
- preste Ed25519 RunCertificate ; the agent run is signed and attestable
- witness == live transfer ; bound by hash, not by witness (Phase 1 binding)
- the proof witness and the live Sepolia transfer are linked by a shared hash, not by a single joint witness
- on-chain proof verification ; deferred to Wave 3
- the honest near-term on-chain step is a commitment anchor, not full on-chain proof verification
Read the Phase 1 binding plainly: the STARK proof witness and the live Sepolia transfer are tied together by a shared hash, not yet by a single joint witness. Full on-chain proof verification arrives in Wave 3 ; until then the honest on-chain step is a commitment anchor (demo 05).
Agent-payment demos
Each card shows what the demo demonstrates, the command to run it, and the real Starknet Sepolia transaction it produced. Replay any of them in the terminal above. Every link goes to Voyager, the canonical block explorer.
preste run vauban-payer --demo baseline Runs under the preste vauban-payer agent with an Ed25519 RunCertificate. Block 10331604.
preste run vauban-payer --demo dogfood Same payer agent, a Vauban-operated x402 endpoint as the merchant.
preste run vauban-payer --demo a2a Agent A is the buyer, agent B is the worker and merchant.
preste run vauban-payer --demo compliance Produces an SD-JWT-VC (ES256, RFC 9901) over the settlement receipt.
preste run vauban-payer --demo anchor Two transactions: the payment, then the commitment anchor emitted via emit_receipt.
All five settlements ran on Starknet Sepolia via the self-hosted validator at
https://sepolia.rpc.vauban.tech/rpc/v0_10 ; never a SaaS RPC provider.
STARK throughout ; never SNARK. Vauban Pay is the Starknet-first reference
implementation of the chain-agnostic Vauban Claim Algebra (VPSF).
An agent decided, paid, and walked away with a receipt anyone can verify offline, today, on a public testnet. That is the part that was missing.