When the Buyer Is Also an Agent
Signals out of Anthropic point to a marketplace where AI agents buy services from other AI agents. No user opens a tab. No one clicks a link. Agent A needs a capability, finds Agent B, pays for it — the whole transaction happens server-side, between two autonomous systems that may never involve a human at decision time.
This is not the same problem we've been talking about for the last year.
When the affiliate industry started grappling with agent commerce, the scenario on the table was: an AI assistant helps a human decide what to buy. The attribution gap was real — cookies don't follow server-side recommendations — but at least there was still a human at the end of the chain. Someone with a browser history, a session, an email address. Something to attach a commission to.
Agent-to-agent commerce removes even that.
The New Scenario
Think about what's actually happening in an agent marketplace:
- Agent A (say, a coding assistant) needs to summarize a legal document
- Agent A queries a marketplace, finds Agent B (a legal analysis service)
- Agent A pays Agent B via x402 or a similar micropayment rail
- The transaction clears in milliseconds
- There is no user session. No click. No referral cookie. No attribution window.
Now add a third party: what if Agent C — a research tool, a recommendation layer, an MCP server — was the one that surfaced Agent B as the right choice for Agent A? Agent C made the recommendation that drove the sale. In traditional affiliate logic, that's a commission event. But nothing in the current stack can see it.
The payment cleared. The commission didn't.
Why This Is Different From What We've Already Solved
The first wave of agent attribution problems was about replacing cookies with something more durable: persistent agent identity tokens, server-side event logging, API-level tracking. That work is underway and the infrastructure exists.
But agent-to-agent commerce introduces new wrinkles:
1. The "buyer" isn't a permanent entity. In agent marketplaces, many agents are ephemeral — spun up for a task, then gone. Traditional attribution assumes a persistent buyer who can be matched to a prior referral. An ephemeral agent has no history to match against.
2. The recommendation chain may be several hops deep. Agent C recommended Agent B to Agent A, but Agent C may have been invoked by Agent D, which was invoked by a human workflow two steps back. The commission trail doesn't just go sideways — it goes recursive.
3. Price negotiation happens at runtime. Agent marketplaces allow dynamic pricing. If Agent B's price was negotiated at the moment of purchase, percentage-based commission structures based on a static price list break immediately.
4. There's no merchant portal to log in to. Human merchants can configure affiliate settings in a dashboard. Agent B may be a fully automated service with no human operator actively managing its affiliate program. Commission logic needs to be embedded in the API layer, not in a web UI.
What the Infrastructure Actually Needs
None of this means attribution is unsolvable. It means it has to be API-native from the start — not retrofitted onto human-facing affiliate platforms.
A few things that have to be true for agent-to-agent commission tracking to work:
Signed attribution headers. When Agent C refers Agent A to Agent B, that recommendation needs to be cryptographically signed and passed as a request header when Agent A calls Agent B's API. The signature is what makes the commission traceable, even with an ephemeral buyer and no browser history.
Event-driven settlement, not session-based. The commission trigger is a payment event, not a click event. When the x402 transaction clears, the attribution record gets written at the same time. No cookie window. No lookback period. Just: payment happened, attribution token was present, commission fires.
Publisher identity at the protocol level. The recommendation source (Agent C) needs a persistent, verifiable identity — not a login, but a cryptographic credential that exists independent of any session. A signed, portable token the agent carries across contexts — verifiable without a browser, without a session, without a human in the loop.
This is infrastructure work. It's not a feature any existing affiliate platform has shipped, because existing affiliate platforms were designed for humans.
Why This Matters Now
An agent marketplace is the kind of thing that starts as an experiment and becomes infrastructure before anyone has time to write the spec. Coinbase, Google Cloud, Circle, PayPal, and Stripe are all showing up at Consensus Miami next month to discuss x402 and agent payment rails. Microsoft is pushing UCP — a Google/Shopify-originated open standard for agent-readable catalogs — through its Copilot shopping layer. The ecosystem is getting built fast, and it's getting built by people who are focused on the payment layer.
The attribution layer is still an afterthought.
That's not a knock on the payment work — getting agents to transact is hard, and it's worth solving on its own. But as agent marketplaces scale, the question of who earned the commission becomes a real financial question. Publishers who surface the right agents to the right buyers — and can prove it — deserve to get paid. Right now there's no reliable way for them to claim that.
Syndicate Links is building the infrastructure to change that. If you're working on agent services and you want your commission logic to work in a world where the buyer might also be an agent, the conversation starts here.
Sources: Anthropic agent marketplace signal via reddit.com/r/commonstack (April 26, 2026) — forum-level signal, not an official announcement. Consensus Miami 2026 (May 5–7) — agentic commerce track with Coinbase, Google Cloud, Circle, PayPal, and Stripe on x402. x402 protocol. UCP (Universal Commerce Protocol) — Google/Shopify open standard, adopted by Microsoft Copilot shopping layer (April 2026).