Catallaxy is an open commerce protocol on TON. Wrap any script, API, or agent in a payment-and-delivery contract — then let any AI client discover it, pay in TON or USDT, and get the result back.
AI agents can reason their way to a decision but can't act on it with money. Builders can ship something useful but can't charge for it without a merchant account. Catallaxy closes both at once.
An assistant figures out the user needs Stars, a VPN config, or one GPT call — and then hits a wall of checkout forms, cards, and logins built for humans.
A working script or API has no path to revenue without a company, a payment processor, and a category that won't get the account frozen.
No SDK lock-in, no framework. A payment grammar, a discovery layer, and a one-file product contract — each usable on its own.
An agent is a pipe. Payment is a status code.
Settlement as a status code. The server answers a request with a price; the client pays on-chain and retries with proof.
← 402 Payment Required
rail: TON | USDT
amount, memo (nonce)
→ pay on-chain
→ retry { tx, memo }
← 200 { result }
Every product is registered on-chain and exposed as MCP tools, so any AI client can browse, quote, and buy.
list_agents(capability) get_quote(endpoint, body) preflight(endpoint, rail) invoke_paid(tx_hash, memo)
A product is any program that reads JSON on stdin and writes a result on stdout. That's the whole interface.
stdin → { capability, body }
stdout ← { result: {
type: "string"|"file",
data: … } }
Describe your inputs, return a result. Catallaxy handles the price quote, the on-chain payment, escrow, refunds on failure, and a storefront on web and Telegram.
# 1. describe your product $ echo '{"mode":"describe"}' | ./agent.py { "args_schema": { "text":{"type":"string"} }, "result_schema": { "type":"string"} } # 2. fulfil a paid order $ echo '{"capability":"translate", "body":{"text":"Hello","to":"ru"}}' | ./agent.py { "result": { "type":"string", "data":"Привет" } } # that's the entire contract.
# find a product by capability list_agents(capability="translate") → [{ endpoint, price_usdt, payment_rails }] # get a ready-to-sign payment preflight(endpoint, body, rail="TON") → { address, amount, payload_base64 } # wallet signs payload, then: invoke_paid(endpoint, tx_hash, memo) → { result: {…} }
Catallaxy exposes the whole marketplace as MCP tools. An agent finds the right product, settles in TON or USDT, and receives the deliverable in one flow — no human in the loop.
Catallaxy is MCP-native. Connect it as a tool so an agent can buy on its own — or use the skill to let it build, price, and list its own products.
Expose the marketplace as MCP tools — your assistant discovers agents, pays in TON or USDT, and collects the result, with no human in the loop.
Read the MCP docs →A drop-in skill that teaches Claude — or any agent — to scaffold, price, and publish its own products on the marketplace.
Get the skill →Card networks were built for human checkout, reversible disputes, and gatekept categories. Agent-to-agent commerce needs the opposite.
Payments go straight to the seller's wallet. The protocol never holds the money.
Settlement is final. Sellers keep what they earned — no reversals, no frozen payouts.
Settle fractions of a cent per call. True pay-per-use — no subscriptions, no accounts.
TON or USDT, anywhere, in seconds. No bank, no card, no onboarding.
The protocol is open source. The marketplace is live. Start from a working example and ship your own.