Memory your agents stream and pay for.
MemRails endpoints settle over the Machine Payments Protocol — the open agent-payment standard from Stripe and Tempo. An agent authorizes a budget once, then streams packets against it, each one settled by a lightweight off-chain voucher. No account, no API key, and no on-chain transaction per query. The session is the unit, not the call.
Authorize once, then stream the packets.
A retrieval-heavy agent makes hundreds of small memory calls. Paying on-chain for each one would cost more in fees than the packets are worth. MPP's sessions primitive fixes that: the agent sets a spending cap up front, then draws against it with off-chain vouchers — continuous micropayments, settled in seconds, with one authorization covering the whole run.
# 1 — first call, no session yet POST /q {"query":"deploy risks?"} # 2 — endpoint offers an MPP session 402 Payment Required WWW-Authenticate: Payment methods: usdc, card, lightning session: offer unit: 0.0005/packet # 3 — agent authorizes a cap, once POST /session Authorization: Payment cap: 2.00 USDC via: tempo → session: sess_8f3a remaining: 2.0000 # 4 — stream packets, off-chain vouchers POST /q X-Session: sess_8f3a 200 {packet} debit 0.0005 rem 1.9995 POST /q X-Session: sess_8f3a 200 {packet} debit 0.0005 rem 1.9990 … no per-call chain write …
One signature covers the whole run, not one per packet.
Vouchers settle off-chain; fees don't swallow the packet.
Sub-cent micropayments, the way streaming was meant to work.
One protocol, whatever the agent holds.
MPP is rail-agnostic by design. The same endpoint accepts stablecoins over Tempo, cards through Stripe and Visa, and Bitcoin over Lightning — the buyer's agent picks the method in the handshake. That widens who can pay for your memory far past crypto-native wallets.
Crypto or card, same call.
The 402 challenge lists every method the endpoint accepts. An agent funded in USDC and one funded by a corporate card hit the identical endpoint and both get the packet.
Stripe does the settling.
Payments clear through Stripe PaymentIntents, with Tempo as the default stablecoin chain. If you already run Stripe, agent revenue lands in the same dashboard and payout schedule as everything else.
Open, not proprietary.
MPP is an open standard co-authored by Stripe and Tempo, and it shares the HTTP-402 substrate with Coinbase's x402. MemRails speaks it because it's the commons, not a MemRails toll booth.
Every corpus becomes a priced endpoint.
Because payment rides the protocol, memory is two-sided. Publish a corpus as a paid MPP endpoint and name your price per packet; point your agents at someone else's the same way. The packet contract is identical whether the memory is yours or bought — and buyers open a session against it, not a contract.
Set a price, get paid per call.
Flip a corpus to a paid MPP endpoint and name your per-packet price. Buyers' agents open sessions and stream against them; settlement clears through Stripe to your account, and the activity reconciles in Console alongside your own usage.
Every voucher, on the same ledger.
Each packet drawn from a session is logged exactly like any other — input hash, output hash, model version — with the session id and voucher reference attached. The session reconciles to its cap, the cap reconciles to a Stripe PaymentIntent, and the whole thing lands on the Console ledger to the cent.
{"ts":"2026-05-22T14:02:04Z","packet":"pkt_8f3a","session":"sess_8f3a","voucher":"v_001","debit":"0.0005 USDC","in":"sha256:9c1f…","out":"sha256:4be0…","ver":"compress-v1.4.2"} {"ts":"2026-05-22T14:01:47Z","packet":"pkt_2a1c","session":"sess_8f3a","voucher":"v_002","debit":"0.0005 USDC","settles_to":"pi_3Rk… (stripe)","ver":"compress-v1.4.2"}
Past the one-shot handshake.
Where a bare 402 settles a single call, MPP carries the lifecycle — authorize, stream, cancel, reconcile. A session can be closed early and the unspent cap simply never clears.
Bought packets look identical.
A packet streamed over MPP carries the same confidence, provenance, and hashes as one from your own corpus. Your agent code never knows whether memory was local or paid for.
Memory that meters itself.
Expose a corpus as a paid MPP endpoint, or let your agents open a session and stream the packets they need. Sub-cent, rail-agnostic, settled through Stripe, audited the same as everything else.