Inspiration

AI agents are starting to shop for us. Sellers already pay to win customers: per click to search engines, per sale to affiliate networks and coupon sites. Today none of that money reaches the person buying, and when an agent makes a pick, you can't tell whether it was paid for.

Honey showed what this business looks like for browsers: merchants paid it a commission on purchases where it had applied a coupon, and PayPal bought it for $4B. We asked what that looks like when the one choosing is an agent. An agent isn't persuaded by attention, only by terms, so a seller's money should buy a better deal for the user, stated openly.

The name comes from bees. A honeybee that finds flowers returns to the hive and does a waggle dance to show the others where they are. Waggle does the same for your agent.

What it does

Waggle is an MCP server: Honey for agents. Your agent finds the deal, and PayPal pays you back.

  1. Add it in one line. No account and no login. Adding Waggle is the opt-in; removing it is the opt-out.
   claude mcp add --transport http waggle https://waggle-agents.fly.dev/mcp
  1. Shop in conversation. The agent gets complete organic results plus at most one offer, kept apart and marked sponsored. When it recommends that offer, it says so in the same message: who sponsors it, the deal, and what you get back.
  2. Approve in PayPal, get paid back. You approve the payment yourself. PayPal returns you to Waggle, which captures the payment and pays your share of the seller's fee to the account you just paid with.

The agent's words are the interface. There is no dashboard and no account page.

The fee exists only when a purchase goes through an offer. It is capped at a share of the captured amount and split in one step:

$$ \text{fee} = \min\left(\text{reward per sale},\ \text{cap} \times \text{amount captured}\right) $$

In the demo, a \$79 tent has 10% off and a \$5.00 fee capped at 10%, so the buyer pays \$71.10:

$$ \text{fee} = \min\left(5.00,\ 0.10 \times 71.10\right) = 5.00 $$

$$ \text{payback} = 0.70 \times 5.00 = 3.50, \qquad \text{Waggle} = 5.00 - 3.50 = 1.50 $$

How we built it

Waggle is a hosted TypeScript service on Node, with SQLite on a persistent volume, deployed on Fly.io. Every agent uses the same MCP endpoint over Streamable HTTP, through three tools:

Tool What it does PayPal API
search_products Returns organic results and at most one labeled sponsored offer None
buy_product Creates a checkout for the product the user agreed to buy Orders v2: create
complete_purchase Confirms the purchase and reports the payback Orders v2: capture, Payouts v1

PayPal carries all the money. Orders v2 takes the purchase, and the capture tells us which account paid. A single Payouts batch then pays both the buyer's payback and the publisher's share. Money is handled as integer cents throughout.

The product rules live in the code:

  • Offers stay out of the results. Organic results are complete and in their own order.
  • The user's benefit wins the slot. When several campaigns compete, the largest deal plus payback wins, not the highest fee to Waggle.
  • Sellers don't see the user. Orders carry only campaign and offer ids, never the query, the conversation or the PayPal account.

Challenges we ran into

Removing what we had built. Our first version was a local plugin, which meant keeping PayPal operator secrets in the user's .env. We then built user accounts with Log in with PayPal, personal MCP links and a ledger, and removed them the same day. Everything identity gave us was available elsewhere. Above all, PayPal's capture already tells us who paid, so that account is where the payback goes.

Paying exactly once. PayPal's return page and the agent's complete_purchase can arrive at the same time, and either can be retried. Both run the same settlement code, so one offer buys one order, and that order is captured once and paid out once. PayPal request ids and a unique payout batch id per offer enforce this on PayPal's side too. Our test suite runs the whole flow against a fake PayPal, including both paths racing.

Disclosure through someone else's agent. Waggle doesn't write the final message; the user's agent does. So the offer is marked in the text the model reads, and the server's instructions and tool texts tell the agent exactly what to pass on: that it's sponsored, by whom, and what the user gets.

Attribution. In the demo, Waggle is also the store, so the offer and the purchase meet in one PayPal order and attribution is exact. That is a deliberate shortcut. Sitting in front of any store's checkout means proving to the seller that a sale came through an offer, and that is still unsolved for us.

What we learned

  • A product can need less identity than you assume. Install as consent, plus the payer from PayPal's capture, removed the need for accounts altogether.
  • The conversation can be the whole interface. Tool text is product copy, because it decides what the user finally hears.
  • The split is part of the promise. We started with Waggle keeping 70% of each fee, which looked wrong for a product that says "PayPal pays you back." The user now gets 70%, the share Brave pays users who opt into its ads.
  • Payouts have states worth designing for. Sandbox payouts can take a few seconds, or come back UNCLAIMED when an email has no sandbox account, so the return page and the agent can both check again without paying twice.

What's next

  • A layer the agent consults right before buying at any store, with attribution sellers can trust
  • Approval through a vaulted PayPal account, so agentic checkout takes fewer steps
  • Features that need optional identity: preferences, limits on repeated offers, and receiving payback at a different account

Built With

Share this project:

Updates

Submission history