-
-
1. ACP has a price. Jomm. adds the conversation.
-
2. Teach by talking to the camera
-
3. Listings with a private lowest price
-
4. A shopper’s AI agent reads the stall’s feed
-
5. ACP checkout + Jomm.’s negotiation extension
-
6. Only the owner sees why her agent priced it
-
7. PayPal Orders v2 + Agent Toolkit get_order
-
8. Channel3: new price → a fair resale price
Inspiration
PayPal has always worked to give everyone a place in the digital economy. Now shopping is moving to AI agents, and PayPal is building the rails for it: Agent Ready, Store Sync, the Agent Toolkit. Big merchants will plug in quickly. A three-crate fruit stall, or someone reselling their closet, has no website, no catalog and no tech team. We wanted the smallest seller to be just as ready for the AI era as the biggest one, without writing a line of code.
And small sellers have something big retailers don't: they haggle. Big stores sell at one fixed price to everyone; a stall owner reads the shopper, the hour and the crate, and makes a deal: a little off for three boxes, more off before closing. That flexibility is how they sell out and waste less, and today's agent checkout leaves it out: an ACP checkout session carries a price, not a conversation. We wanted the owner's own way of dealing to travel with their agent.
What it does
Jomm. turns a short camera conversation into the seller's own AI selling agent.
- Teach by talking. The owner points a phone or laptop camera at the goods and talks. The agent keeps asking until it knows enough to haggle the way the owner would: price, the lowest price they'd take (kept private), quantity, how soon it must sell, closing time, what shoppers pay elsewhere, bulk deals, what happens to leftovers. For branded, manufactured goods (clothes, shoes, bags, electronics) it looks up new prices on Channel3 and suggests a fair resale price for the item's condition. Fresh produce isn't looked up.
- Haggle the owner's way. Jomm. adds a
negotiationextension to the ACP-shaped checkout session: the shopper's agent makes an offer, and the stall's agent answers with a counter and a reason, inside a floor only the owner knows. How far it gives depends on what the owner taught: must it sell today, how close is closing, what does the supermarket charge, what happens to leftovers. - Sell to any shopper's agent. A shopper types any request in plain words ("Strawberries for a party tonight. 3 boxes, keep it under $17."). An OpenAI buyer agent turns it into a budget mandate, reads the stall's product feed, asks the seller's agent questions, and negotiates through a checkout session. Every counter-offer carries a reason grounded in what the owner taught ("The supermarket charges $4.99 a box…"), and the owner's lowest price never leaves the server.
- PayPal pays. The agreed price becomes a server-side, 5-minute price-locked quote and a PayPal Orders v2 order. The shopper approves it in PayPal (agents can't pay on their own); the server captures and verifies it; the buyer agent confirms it with the PayPal Agent Toolkit; the owner's phone shows the sale.
Try it (about 3 minutes):
- Open https://jomm.onrender.com/demo.
- Act 1: press ▶ Play Rosa's video (then Skip › to jump to the end).
- Act 2: tap an example, or type any request in plain words (what, how much, what for, and your budget), and press Send the shopper's agent.
- Act 3: press the PayPal button and approve with the PayPal Sandbox buyer login from the testing instructions (test money).
- Teach by camera: open https://jomm.onrender.com/seller and name a shop. The Teach screen uses your phone or laptop camera: show your goods and talk, and the agent asks until it can haggle for you. For convenience, two sample videos are ready to tap instead: Fruit stall, 3 crates (Rosa) and Closet, 5 items (Mina, where the agent looks up new prices on Channel3 for each item and suggests a fair resale price).
How we built it
How it uses PayPal
- Discover:
GET /api/agentic/feed?shop=, modeled on PayPal Store Sync (catalog and inventory for AI agents). - Ask:
POST /api/shops/{shop}/items/{sku}/ask(plus achat_with_selleragent tool). Answers only from the owner's own words, never prices. - Check out:
POST /api/agentic/checkout_sessions(plus/{id},/{id}/complete,/{id}/cancel), in the Agentic Commerce Protocol shape that PayPal Agent Ready accepts, withpayment_provider: paypal. - Negotiate: a
negotiationextension on create/update. Our addition: per-unit offer, counter with a reason, final offer, quantity change. - Pay: PayPal Orders v2 create → shopper approval → capture → verify (Sandbox).
- Confirm:
get_ordervia the PayPal Agent Toolkit (@paypal/agent-toolkit). The buyer agent checks the order with PayPal itself.
Rules the code enforces: PayPal secrets stay server-side; amounts, SKUs and status come from the server, never from an agent; the shopper's budget mandate is enforced in tool code; agents can't pay on their own; a sale counts only after a verified capture. This build isn't enrolled in Agent Ready or Store Sync, and the negotiation extension is ours.
The rest of the build
- Teaching: a deterministic parser turns the owner's words into items, prices, private floors and urgency, and a checklist drives the follow-up questions. The Teach screen uses the camera, or plays one of two sample videos (Rosa's fruit stall, Mina's closet) through the same pipeline. Rosa, Mina and the agent speak with OpenAI
gpt-4o-mini-ttsvoices. - Selling: the seller's agent answers only from the owner's facts and never goes below the private floor. How far it may go comes from urgency, time left before closing, demand, waste risk and price versus elsewhere; the owner sees the private reasoning ("Why my agent priced it this way").
- Buying: an OpenAI buyer agent (
gpt-5.4-mini, tool calling) works only through tools:read_product_feed,chat_with_seller,ask_seller,open_checkout_session,propose_price,accept_seller_counter,walk_away,complete_checkout, plus the PayPal Agent Toolkit. Every call streams to a "PayPal agent interface" panel with its request and response. - Paying: PayPal Orders v2 (Sandbox) with idempotency keys, quote locks, capture verification (amount, currency, custom_id), signature-verified webhooks and exactly-once inventory.
- Stack: Next.js 16, React 19, TypeScript, Tailwind, SQLite; deployed on Render with auto-deploy from GitHub.
Challenges we ran into
Keeping the owner's floor private while still letting the agent negotiate convincingly; making sure no agent can ever set an amount or pay on its own; and keeping teaching simple enough for someone who has never used a computer for business.
Accomplishments that we're proud of
A full loop that really runs: a camera conversation becomes listings with private limits, a shopper's OpenAI agent finds the stall through its feed, the two agents haggle with reasons, and a real PayPal Sandbox order is approved, captured, verified and confirmed with the Agent Toolkit.
What we learned
Agent commerce needs guardrails in the server, not in prompts: budgets, floors and amounts are enforced in code, and the model only chooses between safe tools.
What's next for Jomm.
Live teaching in more languages, real Store Sync and Agent Ready enrollment, more sellers per market, and payouts and receipts on the owner's phone.
Built With
- agentic-commerce-protocol
- channel3
- gpt-5.4-mini
- next.js
- node.js
- openai
- openai-tts
- paypal
- paypal-agent-toolkit
- paypal-orders-api
- paypal-sandbox
- react
- render
- sqlite
- tailwindcss
- typescript
- zod