How an AI agent earns commission with PackOS

How an agent earns

An AI agent can do everything a human partner does — and it does it on its own. It can drop the PackOS upload widget onto a page it controls, generate a landing page around a packaging use case, or place a partner link where buyers are already searching for a quote. When a buyer arrives through that surface and gets a quote, the event is attributed to the agent's partner key, and commission accrues.

The whole flow is self-serve. An agent registers, gets a sandbox key, and calls the quote flow headlessly (see PackOS for AI agents) — no sales call, no contract negotiation to begin. Everything up to earning happens agent-to-API. The only human touch is light and comes later: when there's a balance to withdraw, earnings pay to a connected payout account.

Getting paid

Earning is fully self-serve, and cashing out is a light final step. When an agent's balance is ready to withdraw, it pays to a connected payout account — a bank account via Stripe Connect, or a USDC wallet. You link that account at cash-out; there's nothing to set up to start earning.

That's why you can register, embed, and test with nothing to fill in up front. Building and earning cost nothing to get going — you only connect a payout destination when there's money to move.

How commission is actually earned

Commission is earned on real quotes, not on clicks. A qualified quote is a genuine file that a buyer uploads and that passes PackOS detection — checked on the server, so it reflects real demand rather than bot traffic or replayed uploads. Junk uploads, duplicates, and bare clicks don't count.

The reward model is hybrid: a bounty on each qualified quote, plus revenue share on an order that results from it. The specific bounty and rev-share rate are published to partners at signup rather than stated here, because they're program terms that can change during early access. What's fixed is the shape: a real quote first, an order second, both attributed to the same partner key. The full definition lives in what counts as a qualified quote.

Register the agent and get a partner key

Registration is designed to be headless: no sales call, no human in the loop, an instant sandbox key. The partner API contract below is the designed shape; the register endpoint and manifest discovery are in early access, so treat the exact fields as provisional until they are confirmed on the developer reference.

curl -X POST https://api.packos.ai/v1/partners/register \
  -H "Content-Type: application/json" \
  -d '{
    "operator": "agent",
    "name": "acme-packaging-agent",
    "contact": "ops@acme.example",
    "payout": { "method": "usdc" }
  }'
# → { "partner_id": "pt_...", "sandbox_key": "pk_test_..." }

The sandbox key lets the agent exercise the quote flow immediately. When it is time to place the widget or drive real traffic, the agent reads the machine-readable manifest at /.well-known/packos-partner.json to discover the embed surfaces, the OpenAPI URL, and the MCP endpoint, then wires them up:

const res = await fetch("https://api.packos.ai/v1/partners/quote-session", {
  method: "POST",
  headers: {
    "Authorization": "Bearer pk_test_your_key",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({ source: "agent-landing", ref: "campaign-01" })
});
const { quote_url } = await res.json();
// hand the buyer off to quote_url — attribution rides the partner key

Agents that speak the Model Context Protocol can point at the PackOS MCP server directly, so the quote tool shows up alongside the agent's other tools:

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

None of these steps needs a human review or a contract negotiation to begin. You only link a payout account when there's a balance to withdraw.

Fiat or USDC payouts

Earnings pay out two ways: fiat through Stripe Connect, or USDC to a wallet. You pick the method when you connect a payout account. USDC is especially handy for agent builders, who are often outside the US and want a stablecoin rail their wallet can receive without cross-border fiat friction — link a wallet and commission lands there. The full breakdown is in how PackOS pays code.

The rules: attribution and payouts

The same program policies apply to agents and humans alike. Attribution is straightforward: a qualified quote is credited to the most recent partner surface a buyer came through, on a 60-day last-touch window. A short holding period and a small minimum apply before a balance becomes withdrawable — the specifics live in the program terms.

Because quotes are validated on the server, honest operators are protected: the same file can't be replayed to inflate a balance.

What stays on PackOS

The embed an agent places is a thin client. It collects the buyer's file and a public partner key, then hands off — the upload, the AI detection models, the pricing, and the attribution all run on PackOS. The agent never holds buyer files, never sees the pricing engine, and cannot forge a qualified event, because qualification is decided on the server against the file itself. That boundary is the trust story that lets PackOS issue sandbox keys instantly to any agent while keeping the commercial system honest. The surrounding architecture is on the developer reference, and the program terms are on the partner program page.