Procuro

Send your agent to negotiate with theirs. Seller agents on their own servers haggle with yours over A2A, every deal is signed with AP2, and PayPal holds the money until the goods arrive.

Comment

Inspiration

Small business owners lose roughly four to seven hours a week buying supplies and doing the paperwork around it (Walmart Business research, 2026). Meanwhile, McKinsey estimates AI agents could run up to $1 trillion of US retail by 2030.

Most "AI shopping" demos are one agent searching a catalogue. But the interesting future is agents buying from other agents: a coffee shop's agent haggling with a supplier's agent. That raises a hard question: when two pieces of software negotiate and move money, who can prove what was agreed, and who stops an agent from overspending?

Procuro is our answer: send your agent to negotiate with theirs, with every promise signed and PayPal holding the money until the goods arrive.

What it does

Meet Sam, who runs a small coffee shop and goes through 500 paper cups a week.

  1. He connects PayPal once (PayPal Vault) and sets a monthly cap. Auto-pay lets his agent pay small deals on its own.
  2. He writes what he needs in plain words: "500 paper coffee cups with lids, 12 oz. Budget \$300. Ask me before paying anything over \$200." He picks the delivery day on a Bryntum Calendar that already shows every delivery, payment, hold renewal and dispute in flight.
  3. His agent finds the exact product with Channel3, with real prices from every retailer.
  4. Procuro signs his rules as AP2 mandates, then his agent negotiates over A2A with 3 seller agents at once: 3 outside agents (NorthBox, SwiftPak, EcoCarton) running on their own servers, with their own keys and their own PayPal accounts. It drops a seller that can't meet the deadline and counters the rest using market prices and competing quotes.
  5. The winner signs an AP2 checkout. The deal is under Sam's limit, so his agent signs the payment itself. The seller checks every signature before asking PayPal for anything.
  6. PayPal only holds the money (intent: AUTHORIZE). Nothing is charged until the cups arrive.
  7. When a case arrives crushed, Sam reports it with a photo. Claude assesses the damage, the agents negotiate, and PayPal captures only the fair part:

$$\text{capture} = \text{usable units} \times \text{agreed unit price}, \qquad \text{returned to Sam} = \text{hold} - \text{capture}$$

  1. Every order has a receipt anyone can check: each signed AP2 document with its fingerprint, linked to the PayPal order, authorization and capture it caused, and compared with PayPal's own records. It can be re-verified offline with Google's AP2 SDK.

There's also a Bryntum Gantt of each order's life, a Bryntum Scheduler of every seller's production (fully booked days push their quotes later), and an AG Studio Spend dashboard with an AI analyst that answers questions and builds charts.

How we built it

  • Backend: FastAPI on Heroku, with Firestore for orders and the agents' conversations.
  • A2A: every seller publishes an agent card at /.well-known/agent-card.json with its signing key. The outside sellers are a separate app built on the official A2A Python SDK (v1.0 with v0.3 compatibility), deployed as their own Heroku apps.
  • AP2 v0.2 with Google's AP2 SDK:
    • open checkout and payment mandates (SD-JWT, ES256) signed by Sam's trusted surface
    • seller-signed Checkout JWTs
    • closed mandates, signed either by the agent ("human not present") or by Sam ("human present")
    • signed receipts and signed error receipts when the rules don't fit
  • PayPal (official Server SDK):
    • Vault v3 (connect once) and Orders v2 with vault_id for auto-pay
    • authorize, full and partial capture with final_capture, reauthorize after the honour period, and void
    • idempotent PayPal-Request-Ids on every call that moves money
    • Invoicing through the PayPal Agent Toolkit to split a bulk order with a neighbour
  • Claude for negotiation, parsing requests, damage assessment, explanations and the dashboard analyst. Hard limits live in code, not in the prompt.
  • Frontend: React on Netlify, with Bryntum Calendar, Gantt and Scheduler, AG Studio, and Channel3 for product and market data.

Challenges we ran into

  • A saved PayPal belongs to one app. Auto-pay worked for the built-in sellers, but an outside seller with its own PayPal app can't charge a payment method saved by ours. PayPal confirmed it with BILLING_AGREEMENT_NOT_FOUND. We turned this into a feature: the outside seller refuses with a signed AP2 error receipt (payment_instrument_unavailable), and Sam approves on PayPal instead.
  • Making AP2 enforce what we meant. The SDK checks quantity only as a maximum, so we enforce exact quantities ourselves, and we fill in the Checkout fields the SDK requires.
  • Agents on different servers. Local and live runs share one database, so an order placed on a laptop pointed sellers at localhost. We now resolve each seller's address at request time. Failures that used to be swallowed now show in the chat ("Couldn't reach", "No quote").
  • Protocol details: the A2A SDK's protobuf turns integers into floats, so quantities like 500 arrived as 500.0 and had to be converted back.
  • Real product data: Channel3 lists packs, not single cups, so the agent has to read pack sizes before comparing prices.

Accomplishments that we're proud of

  • Real independent agents: outside sellers on their own servers, with their own keys, PayPal accounts and private floor prices. Nothing is scripted.
  • A full AP2 v0.2 chain, including refusals, verified both in the app and offline.
  • Money that moves only when it should: holds, partial captures and releases with every step linked to a signature.
  • PayPal platform mode, tested in sandbox: a seller sign-up link, and a \$1.00 payment captured with a \$0.10 platform fee for Procuro.

What we learned

  • Agent-to-agent commerce needs proof, not just chat. Signatures turn "the agent said so" into something anyone can check.
  • An authorization hold is the right place for an AI agent: it can commit to a deal without being able to take the money.
  • Keep the rules in code and let the model do what it's good at: negotiating, explaining and judging evidence.

What's next for Procuro

  • PayPal's native AP2 support, with PayPal signing its own receipts.
  • Platform mode in the app, so sellers sign up through Procuro and Procuro earns a platform fee.
  • Shared vaulting, so auto-pay works with every outside seller.
  • More seller agents joining through nothing but an A2A card.

Built With

Share this project:

Updates

Submission history