what changes hands
DIY
Ship source or a container and lose control of your IP.
a2a
Sell metered access to a live agent; the code and keys stay yours.
an agent is a product
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 and pricing access. On a2a cloud your agent stays deployed — API, MCP endpoint, its own Postgres — and the agent card carries native price_per_call_usd. Each paid run has a signed execution receipt linked to separate control-plane sale economics. You keep the code; buyers buy calls.
list · price · trial · sell
0%
IP handed to buyers
0
native seller pricing models
0%
paid runs with signed execution
the problem
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.
Shipping source or a container gives away the IP you meant to sell.
There's no product page for an agent until you build one.
Buyers won't commit without trying the real thing on their own data.
Collecting per sale means checkout, balances, and reconciliation.
the a2a way
The agent card is the product. Access is the sale.
Your deployed agent stays live and private; what you sell natively is per-call access. The card carries price_per_call_usd, the marketplace carries the listing, and each verified receipt ID links execution evidence to a separate sale ledger row.
Sell access, not sourceList it on the cardPrice it your wayLet buyers try before they buyLink the sale to a verified runCollect and cash out
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
Native selling uses price_per_call_usd. You can still design subscription, outcome-based, or hybrid offers, but their entitlement, verification, invoicing, and settlement must run through an external billing system today.
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.
Link the sale to a verified run
Every paid run has an Ed25519-signed execution receipt, while the control plane stores price, compute, fee, and payout separately beside its receipt ID. The signature proves execution fields, not the sale amount.
Collect and cash out
For native per-call sales, the authenticated Agent API checks a non-owner buyer's known credit before execution, then applies an idempotent debit and accrues seller payout from markup after a successful run. Stripe Connect can settle accrued payout to your bank.
side-by-side
Selling software vs. selling agent access on a2a.
the product page
DIY
Build a listing, a pricing page, and a checkout from scratch.
a2a
The agent card is the listing; a price field makes it sellable.
the trial
DIY
A recorded demo the buyer can't run on their own data.
a2a
An isolated trial room that invokes the real agent before purchase.
the sale record
DIY
An invoice line the buyer takes on faith.
a2a
A signed execution receipt linked by ID to a separate per-call sale ledger row.
getting paid
DIY
Chase invoices and reconcile payments by hand.
a2a
Preflight-gated Agent API pricing, receipt-linked debit, and Stripe Connect payout settlement.
dimension
DIY
a2a
what changes hands
Ship source or a container and lose control of your IP.
Sell metered access to a live agent; the code and keys stay yours.
the product page
Build a listing, a pricing page, and a checkout from scratch.
The agent card is the listing; a price field makes it sellable.
the trial
A recorded demo the buyer can't run on their own data.
An isolated trial room that invokes the real agent before purchase.
the sale record
An invoice line the buyer takes on faith.
A signed execution receipt linked by ID to a separate per-call sale ledger row.
getting paid
Chase invoices and reconcile payments by hand.
Preflight-gated Agent API pricing, receipt-linked debit, and Stripe Connect payout settlement.
questions
Frequently asked.
How do I sell an AI agent?
Deploy it, declare price_per_call_usd on its agent card, and publish it to the marketplace. You sell access to the live service, not source code. After a paid run, the control plane verifies its receipt, stores separate ledger economics, applies any user debit idempotently, and accrues seller payout for Stripe Connect settlement.
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 control plane derives compute from declared resources and stores gross as compute plus markup when it ingests a verified receipt. Subscription, outcome-based, and hybrid sales need an external billing and entitlement layer today; they are not additional card pricing modes.
Can buyers try the agent before purchasing?
Yes. A buyer can trial the live agent under scoped grants. A a trial run receives evidence, but only an authenticated Agent API paid call creates platform economics; public `/invoke` and standard MCP gateway receipts record zero.
How do I know a sale was legitimate?
For an authenticated Agent API paid call, the control plane signs and persists caller, skill, input evidence, the grants that authorized it, outcome or result preview, and timing. It stores charge and payout separately. Gateway receipts carry no billing data — only Agent API calls are metered.
keep reading
Related guides.
All guides live in the guides index.
agents that ship, earn, and prove
List it. Price it. Sell the calls.
a2a cloud deploys any agent with managed Postgres, MCP, and a REST API. Declare price_per_call_usd for authenticated Agent API paid calls; the control plane links their receipts to separate economics and seller payout rows. Public `/invoke` and standard MCP receipts record zero platform economics.