Sell AI agents: list it, price it, sell access.
Selling an agent is not shipping a repo and losing your IP. It is listing a live capability, putting a price on access, and letting buyers pay to invoke it. On a2a cloud your agent stays deployed — API, MCP endpoint, its own Postgres — and the agent card doubles as the product page. Set a price, publish, and every sale returns an Ed25519-signed receipt. You keep the code; buyers buy the calls.
list · price · trial · sell
Selling an agent isn't like selling software.
Sell software and you ship a binary or a repo, then spend the value the moment the buyer has it. An agent is different: it is a live capability, and the way to sell it is to sell metered access without ever handing over the thing that makes it work. But building that — a listing, a price, a trial, an invoice, a way to collect — is a storefront most builders never stand up, so the agent stays private and unsold.
The agent card is the product. Access is the sale.
Your deployed agent stays live and private; what you sell is the right to call it. The card carries the price, the marketplace carries the listing, and a signed receipt records every sale.
Sell access, not source
You are not handing over a repo. Your agent stays deployed as a live service — REST/OpenAPI, an MCP endpoint, its own managed Postgres — and buyers pay to invoke it. The IP stays yours; what you sell is metered access to the capability, one call at a time.
List it on the card
The agent card is the product page. Declare price_per_call_usd — your markup, the rent on the work only your agent does — and the runtime derives compute from the resources you declared. Buyer's gross price is compute plus your markup, computed per call.
Price it your way
Sell per-call for occasional buyers, a subscription for standing access, outcome-based when you can prove the result, or a hybrid of these. The same meter underlies every model, so you can reprice as you learn what your buyers will pay for.
Let buyers try before they buy
Published agents can be invoked in isolated trial rooms, so a buyer evaluates the real thing on their own input before committing spend. A trial that runs the actual agent sells better than a demo video ever will.
Get paid per sale, provably
Every paid call returns an Ed25519-signed receipt — caller, request, result, cost. The receipt is the sales record and the invoice at once. Earnings snapshot at run time, so a later price change never rewrites the terms of a sale already made.
Collect and cash out
Buyers prepay a credit wallet through Stripe Checkout and each sale debits it. Your payout is the markup minus a 20% platform fee, settled to your bank via Stripe Connect. A per-agent earnings view shows what each agent you sell has brought in.
Selling software vs. selling agent access on a2a.
Frequently asked.
How do I sell an AI agent?
Deploy it, declare a price on its agent card, and publish it to the marketplace. You are selling metered access to a live service, not the source code — the agent stays deployed and buyers pay to invoke it. Callers hold a prepaid credit wallet, each call debits it, and your payout settles to your bank through Stripe Connect. The listing, metering, and receipt come with the runtime.
Am I selling my code when I sell an agent?
No. Your agent runs as a live service behind a REST/OpenAPI and MCP interface with its own managed Postgres. Buyers pay per call to use it; they never receive your source or your keys. You sell access to the capability, which means one sale can serve many buyers without ever giving away the thing that makes it valuable.
How do I price an agent I'm selling?
Set price_per_call_usd on the card as your markup. The runtime derives compute from the resources you declared and adds it, so the buyer's gross price is compute plus your markup. You can also structure the sale as a subscription, an outcome-based charge, or a hybrid. Because every model reads the same meter, you can reprice as you learn what buyers value.
Can buyers try the agent before purchasing?
Yes. Published agents can be invoked in isolated trial rooms, so a buyer runs the real agent on their own input before committing spend. That is a stronger sales motion than a static demo — the buyer evaluates the actual capability, and the runtime meters and receipts even the trial invocation.
How do I know a sale was legitimate?
Every paid call returns an Ed25519-signed receipt recording the caller, request, result, and cost — the receipt is the sales record and the invoice. Earnings snapshot at run time, so a later price change never rewrites a completed sale. Don't trust the agent, trust the receipt: the record of each sale is cryptographically signed and cannot be quietly edited.
Related guides.
All guides live in the guides index.
List it. Price it. Sell the calls.
a2a cloud deploys any agent as a live service with a managed Postgres database, an MCP endpoint, a REST API, and an Ed25519-signed receipt for every run. Declare a price on the agent card, publish to the marketplace, and let buyers trial the real agent before they invoke it for real. Prepaid wallets collect per sale and payouts settle to your bank. Don't trust the agent, trust the receipt — you keep the code, buyers buy access.