Paygent is not a proprietary API — it is an agent that speaks the Universal Commerce Protocol: a discovery document, an agent card, and an MCP checkout endpoint. If your runtime can call a tool, it can search, pick the card that earns most, spend points, and complete the checkout.
All money and points math is deterministic and server-side — never delegated to a model.
# 1 · Discover the agent over standard surfaces card = fetch("https://agent.example.com/.well-known/agent_card.json") ucp = fetch("https://agent.example.com/.well-known/ucp") # 2 · Open a session — bound to YOUR wallet provider session = paygent.post("/v1/sessions")["session_id"] # 3 · Stream a turn · typed events, never prose to parse for ev in paygent.stream("/v1/run", session_id=session, message="5.5-quart Dutch oven under $250 — which card earns the most?"): match ev.type: case "products": ui.offers(ev.data) case "checkout_summary": ui.cart(ev.data) case "wallet_summary": ui.wallet(ev.data) case "verbatim_block": ui.as_is(ev.data) # money: render, never re-derive case "message": ui.text(ev.data) # → earning quoted per card on the real cart · points held in escrow # → checkout binds to the offer shown, at the price shown
/.well-known/ucp
Agent card · /.well-known/agent_card.json
MCP checkout · /ucp/mcp
No proprietary SDK required to start — the same surfaces the UCP ecosystem uses for discovery and checkout are how you talk to Paygent.
Agent card at /.well-known/agent_card.json: the commerce agent's identity, capabilities and endpoint. Signing keys are pinned out of band at onboarding, never fetched over the network.
The /.well-known/ucp document advertises the checkout capability and its MCP endpoint — machine-readable and versioned.
Create, get, add items to, complete, and cancel checkouts as MCP tool calls — completion and cancellation are idempotent on the caller's key.
Paygent moves value through a wallet agent it does not own. That seam is a versioned specification, to be published with the SDK release, that any wallet vendor can implement without reading our source.
1.x contract, currently 1.1A self-contained guide: discovery, authentication, transport, operations, idempotency, errors, and the KYA test. Frozen at the platform's v1.0.0 release; changes since then are additive, plus coordinated errata.
Ten tool calls — instruments, payment credentials, loyalty balance, earning quotes, accrual, card events, and the reserve / capture / release redemption lifecycle, plus user approval requests — and a sandbox-only test-approval tool. MCP over JSON-RPC 2.0.
RFC 9421 message signatures over Ed25519, verified in both directions with Content-Digest binding. Your agent authenticates us as strictly as we authenticate it.
Durable keys with replay semantics and a defined conflict rule — the same key with different arguments is an error, not a second debit. A named error vocabulary instead of prose.
A portable harness: point it at any base URL, get pass, fail or not-implemented per checklist item, and a non-zero exit on any failure for CI. Language-neutral wire vectors — signature bases, digests, cart hashes. Public when the SDK is released.
We built a second, clean-room implementation of the agent from the written spec alone, with no access to our source.
Anyone can wire an LLM to a product feed. What you do not want to build twice:
Totals, discounts, and point earning are composed in service code and streamed as sealed verbatim blocks. The splice is structural — the model never sees the number, so correctness does not rest on prompt discipline.
Before an external wallet agent moves value, it checks who is calling and whether each spend-affecting call is within a scoped, capped, expiring mandate. Before capture, it also checks that the user approved these items at this price. Cart-bound approval, cryptographic accountability, not a chat log.
Bind sessions to your wallet provider — cards, balances, points. The loyalty engine handles escrow, real-time redemption, and crash-safe capture behind one interface.
Any OpenAI-compatible server — LM Studio, vLLM, Ollama — or a hosted frontier model, selected by environment, with per-role overrides so routing can run smaller than composition. Correctness lives in the services, so an 8B model is a real option.
Post card events and points accrue against the program ledger and settle on Stellar testnet — idempotent on the event id, with a member provisioned just in time on first sight. The earn side of the loop is an API, not a batch file.
Adds resolve against the offers discovery actually showed, carried on the session, at the price shown — superlatives and ordinals are arithmetic over that set, not a second keyword search that can land on the wrong item.
Your existing assistant delegates commerce intents to Paygent over MCP / agent-card discovery. Lightest touch.
Sessions and streamed turns over the versioned /v1 HTTP contract. Our own reference web chat consumes nothing else — what we build on is what you get.
Run the full engine under your brand with your catalog and your wallet provider behind the interface.
We are looking for our first design partners — host runtimes, platforms, and wallet providers — ahead of general availability.