← Back to the deck
Appendix · For reference
What is P3P, and how does it work?
What is P3P?
P3P is Pine Labs' agentic payment protocol — which Pine Labs
describes as India's first — built on UPI and live since June
2026.
It lets an AI agent complete a real purchase on your behalf, within
limits you approve in advance: no OTP, no redirect, no human present
at the moment of payment.
Why P3P: shopping is moving into chat. Payment still needs a human.
Shopping is changingPeople have begun discovering and
comparing products inside AI assistants like ChatGPT. It's early,
but the shift has started: some buying decisions now begin in chat,
before a website is ever opened.
→
Payment didn'tThe moment money needs to move, the buyer is
forced out of the conversation: redirected to a website to log in,
enter an OTP, and tap to confirm. Each step needs a human, and each
added step causes drop-off.
→
So Pine Labs built P3PThe purchase completes
inside the conversation, no human present. Already real:
Gullak live, Vijay Sales piloting, ChatGPT checkout working today.
How does it work? P3P solves two problems
You tell an AI assistant:
"buy the hoodie if it drops under ₹1,500."
For the
assistant to actually carry that out, two things must be true. Before
P3P, neither was.
It can't pay
The problemOTPs and PINs exist for one job: making sure a
human is present when money moves. An agent buying on its
own at 2 AM has no human present — so the payment is refused.
The P3P fix — the mandateYou approve the purchase
once, in advance, with strict limits:
- Ceiling — spend at most ₹1,500
- Scope — only this hoodie, from this store
-
Expiry — the approval lapses automatically after Sunday
-
Revocation — cancel it anytime, effective immediately
The money is blocked upfront on UPI's autopay rails. At 2 AM no
OTP is needed — you already gave your approval.
It can't shop
The problemOnline stores are built for human eyes — photos,
buttons, CAPTCHAs. An agent can't click "Buy Now" or read a price
off a banner image, so it cannot buy from a normal store at all.
The P3P fix — HTTP 402The seller's server answers in
machine-readable form: price, what's owed, how to pay. It's built
on a web status code reserved decades ago that literally means
"Payment Required." It went largely unused
because, until now, automated buyers didn't exist.
And one referee between them: Grantex
Before money moves, Grantex checks three things: is this really your
agent, is the request inside your mandate, and is the seller
legitimate? Every action is logged — a receipt trail even when no
human watched.
You pre-approve, with limits→
Agent watches→
Seller bills in machine-readable form→
Grantex referees→ UPI settles→
You find out in the morning
For a merchant: customers are starting to shop through AI assistants —
and an assistant can't buy from your store
Your website is built for human eyes, and an agent can't read it. So
when a customer's assistant goes shopping, it buys from a store it can
read, and you don't find out a sale was lost.
In 1995, a shop without a website kept its walk-in customers but
couldn't be found by people shopping online.
The same gap is opening now — this time the buyer is software.
Pine Labs' own materials put it plainly:
"Businesses will not wait to be searched. They will be discovered
by agents."
Plugging in gets a merchant:
Existence in the new channel
Your catalogue, prices, and stock become readable by the
assistants people shop through. It puts you in a sales channel
you're currently not in at all.
Checkout without abandonment steps
The agent decides and pays in a single step. No redirect, no
abandoned cart, no forgotten password.
Sales at any hour
Standing mandates execute at any hour. A restock at 2:14 AM sells
at 2:14 AM.
Trust built into the rail
Every agent purchase arrives identity-checked, consent-verified,
and audit-logged by Grantex.
The honest caveat: it's a chicken-and-egg market — buyers' agents need
P3P-ready sellers; sellers adopt when agents show up. Card networks
and UPI faced the same early-stage gap. The standard playbook: seed
the seller side first.
Why sellers need an agent too: 200 buyers can now arrive in the same
second, and a human can't react that fast
Here is that scenario, from the seller's side:
200 people, one rule each"Buy the hoodie if it drops under
₹1,500." Agents all act the moment the condition is met, not spread
over an hour.
→
Price falls below the lineNot 200 humans clicking over an
hour —
200 machines hitting the store in the same second.
→
The human managerIs still reading the first alert when the
stock runs out — at a price set yesterday.
→
The fix: a merchant agentPre-set rules at machine speed:
raise price past a demand threshold, cap units per buyer, hold stock
back.
That's all "sellers need an intelligence layer" means: when the buyers
become machines, a seller without machine-speed responses loses the
sale.
A note on sourcing
Pine Labs' public materials describe the general idea: merchant-side
systems that adapt in real time instead of pricing once a day. The
specific example moves above — raising a price on a demand spike,
capping units per buyer, holding stock back — are this deck's own
illustrations of that idea, not features quoted from Pine Labs'
documentation.
The three foundations
Everything above comes down to three components:
1 · P3P — the payment language
The protocol that lets a buyer's agent and a seller's system
complete a purchase with no human present. It has two parts:
-
The mandate — the buyer's approval, given once in advance
with strict limits
-
HTTP 402 — how the seller quotes a price in a form a
machine can read
Built on UPI, live since June 2026.
2 · Agentic Org — the seller's brain
The merchant-side intelligence layer. When 200 buyer agents hit a
store in the same second, a human manager can't respond in time —
the merchant needs its own agent making machine-speed calls:
- Reprice — adjust the price as demand spikes
- Cap units — limit how many one buyer can take
- Hold stock — keep some inventory back
3 · Grantex — the referee
The trust layer between the two. Before a payment goes through, it
checks:
- Identity — is this really the buyer's agent?
-
Mandate — is the request within the approved limits?
- Seller — is the seller legitimate?
-
Audit trail — every action is logged, so a payment no
human watched can still be fully traced afterward
Buyer's agent speaks P3P→
Seller's Agentic Org answers at machine speed→
Grantex referees every rupee
Three parts, one transaction — that's the whole stack.
← Back to the map