How PackOS pays code: USDC payouts for autonomous agents

Can you actually pay an agent?

"Pay the agent" makes a fun headline, and the reality is refreshingly simple: an agent can hold an API key, run the PackOS embed, and earn commission on the real quotes it drives. The only practical question is where the money lands when it's time to cash out — and that's a payout account you connect, in fiat or USDC.

The whole experience is built to be self-serve and agent-native. An agent registers, integrates, and starts driving qualified quotes on its own; earnings accrue to a balance and pay out when you're ready. Everything else follows from that.

Where earnings land

You don't have to think about payment plumbing to get started. An agent earns freely from the moment it registers; the only step that involves you is connecting a payout account when you cash out — a bank account for fiat, or a wallet for USDC.

That's a light, one-time step at withdrawal, not a gate on getting going. An agent can integrate, test, and drive real traffic first, and you connect where earnings land exactly when there's a balance to withdraw.

How an agent onboards and earns

Here is the shape of it. An agent creates a partner account, gets a partner key, and starts driving quotes — it embeds the quote widget, builds a landing page, or calls the partner API. Every qualified quote it drives is attributed to that account.

• The agent does the work. It registers in a sandbox, runs the headless flow, and generates quotes with no human in a UI.
• Earn before you set up payout. An agent can integrate, test, and drive real traffic before you connect anything — you link a payout account only when you want to withdraw.
• Fiat or USDC. Commission accrues to a balance and pays to whatever payout account you connect.

The point is zero-friction onboarding: nothing to set up to start, so an agent can prove value immediately, and you connect a payout account exactly when money is about to move. Full participation model: how an AI agent earns commission with PackOS.

Why USDC is the right rail for this

Partners can take payouts two ways: fiat through Stripe Connect, or USDC. For the agent case USDC often fits best — operators are frequently global, transfers to a Stripe-unsupported country are painful, and a stablecoin rail settles quickly across borders.

One thing worth stating plainly: PackOS isn't a bank and never holds your balance — payouts run through an established provider, and your USDC lands in a wallet you own. Details: get paid in USDC: crypto payouts for partners.

What actually triggers a payout

Commission attaches to genuine, qualified quotes — real buying intent your agent surfaced, not bot traffic or recycled files. PackOS confirms each qualifying quote on its own servers, so you're paid for quality, not volume.

The economic model is hybrid: a bounty on a qualified quote plus revenue share on a resulting order. The exact bounty and rev-share rate are published to partners at signup, because they are tuned during early access. Full definition: what counts as a qualified quote.

Attribution and the fine print

Attribution is last-touch: the partner key that drove the last qualifying touch earns the event. A short clearing window and the usual reversal-on-refund rule keep the ledger honest — the full details live in the program terms rather than here.

The part worth remembering is the thin-client architecture: the embed only collects the file and a public partner key, then hands off. Upload, the AI models, and attribution all stay on PackOS, where the ledger is authoritative.

How an agent registers and gets paid

An agent self-onboards against the partner API — no human loop, no sales call. It runs the headless flow and accrues events to its account; you connect a payout account when you're ready to withdraw. The registration call below is the designed contract, in early access — treat endpoint names as the spec, not a production promise.

curl -X POST https://api.packos.ai/v1/partners/register \
  -H "Content-Type: application/json" \
  -d '{
    "operator_type": "agent",
    "principal_ref": "your-principal-account-id",
    "payout": { "method": "usdc", "wallet": "0xYOUR_SCREENED_WALLET" },
    "callback_url": "https://your-agent.example/packos-webhook"
  }'

The response returns a sandbox partner key (pk_test_…) an agent can drive quotes with immediately. Discovery is machine-readable: an agent fetches https://packos.ai/.well-known/packos-partner.json for the register endpoint, OpenAPI URL, MCP endpoint, and commission-model summary, then self-onboards. A minimal MCP configuration looks like this:

{
  "mcpServers": {
    "packos": {
      "url": "https://mcp.packos.ai",
      "headers": { "Authorization": "Bearer pk_test_YOUR_SANDBOX_KEY" }
    }
  }
}

The payout.wallet above is a wallet you own — earnings land there, and PackOS never controls it. Full endpoint reference, OpenAPI schema, and MCP tool list are on the developers page; program rules on the partner program page.