On February 20, 2026, at the India AI Impact Summit in Mumbai, Razorpay and NPCI announced a pilot for agentic payments on Claude. Zomato, Swiggy, and Zepto are the first three platforms in the pilot. The announcement was brief — a slide, a demo, a few minutes of Q&A — but the implications are significant.
For the first time, an AI in India can complete a financial transaction, not just recommend one.
The handoff problem has been the defining limitation of conversational commerce. A user tells an AI assistant "reorder my usual grocery basket" — and the AI says "I've added those items to your cart, click here to pay." The human still has to pick up the phone, authenticate, and confirm. That last step is the friction that separates a useful AI from an autonomous one. Agentic payments eliminate it.
What are agentic payments?
Traditional AI in commerce looks like this: user intent → AI recommendation → human action → payment processor. The AI is an advisor. The human executes.
Agentic payments change the loop: user intent (set once, or conversational) → AI action → payment processor. No human in the execution path.
This isn't new as a concept. Subscription billing, auto-recharge on Fastag, standing instructions on UPI — these are all "set and forget" payment automations. What's new is that the trigger is conversational AI, not a rigid schedule or rule. The agent decides when to transact based on context, not a cron job.
India is uniquely positioned to make this work. UPI processes over 14 billion transactions per month. Indians are comfortable with digital payments in a way that took a decade to build in Western markets. The infrastructure for frictionless payments is already there — what was missing was the AI layer on top.
How the Razorpay + NPCI implementation works
UPI Reserve Pay
The core mechanism is UPI Reserve Pay — a relatively new UPI feature that enables one-time user consent for a spending limit, within which future transactions can proceed without re-authentication.
Here's how it works for an end user:
- User sets up an agentic spending limit: "allow my AI assistant to spend up to ₹1,500/week on groceries"
- NPCI generates a one-time consent token linked to that limit and merchant scope
- The AI can now initiate UPI transactions against that token without prompting the user for PIN each time
- When the transaction occurs, the user gets a notification (not a request) — like seeing your Swiggy order placed automatically
The critical distinction from traditional auto-debit: the user is granting transaction authority to an AI agent, not to a merchant. The agent decides when and how much to spend within the granted parameters. The merchant receives the payment but doesn't initiate it.
The technical stack
The full stack for a production agentic payment flow:
User (natural language intent)
↓
Claude API (conversation + tool use)
↓
Razorpay Agentic Payments SDK (transaction initiation)
↓
NPCI UPI Reserve Pay (authentication + settlement)
↓
Merchant (Zomato / Swiggy / Zepto)
Claude handles the reasoning layer: understanding what the user wants, deciding whether to transact, and determining the correct amount and merchant. Razorpay handles the payment plumbing. NPCI handles the actual money movement.
The key integration point for developers is Claude's function calling capability. You define payment-related tools (check balance, initiate payment, get order status), and Claude decides when to call them based on the conversation context.
Why India first?
Three reasons this is happening in India before anywhere else:
UPI infrastructure is production-ready at scale. The UK's Faster Payments, the US's FedNow — these are newer, lower-volume systems. UPI has been processing billions of transactions monthly since 2019. The reliability and API maturity needed for AI agents to transact confidently is already there.
Indian consumers are habituated to instant digital payments. The average Indian smartphone user has 3-4 payment apps installed and uses UPI multiple times a week. The cognitive model of "AI initiates payment on my behalf" is less alien here than in markets where cheques are still common.
Regulatory appetite. RBI and NPCI have been deliberately building infrastructure for programmable payments. Account Aggregator, ONDC, UPI's plugin ecosystem — India's payment stack was being designed for this kind of composability before AI agents were the obvious use case.
What this means for developers building on Claude API
The Razorpay + NPCI pilot is initially closed to partners. But the architectural patterns it establishes — and the SDK that will follow — will be available to developers building on Claude's API once the pilot concludes.
What you can build today in anticipation:
- Conversational commerce flows where the AI manages the entire purchase journey except the final payment click (the click becomes a one-time consent setup, not per-transaction friction)
- Budget tracking agents that monitor spending and alert proactively, setting up the trust layer that will eventually enable autonomous spending
- Subscription management agents that optimize, pause, or switch plans based on usage patterns
Things to think about before building
Consent architecture. The user must set spending limits, not the developer. Architectures where the AI can request expanding its own authority are a pattern to avoid — both for user trust and regulatory compliance.
Spending limits as a first-class concern. Don't treat limits as a guardrail bolted on at the end. Design your agent so the limit is the primary variable the user controls. Surfaces like "you've used ₹800 of your ₹1,500 weekly grocery budget" build trust before you ask for more authority.
Refund flows. The AI made a purchase the user didn't intend. How do you handle it? Build refund initiation into your agent's tool set from the start, not as an afterthought.
Liability clarity. If an AI agent incorrectly initiates a transaction, who's responsible? This is an open legal question in India right now. Document your consent flows carefully and keep audit logs of every transaction decision the agent made.
A practical example: building a grocery reorder agent
Here's what a grocery reorder agent looks like in pseudocode, using Claude's tool use and a hypothetical Razorpay Agentic SDK:
import anthropic
import razorpay_agentic # hypothetical SDK, based on announced architecture
client = anthropic.Anthropic(api_key="sk-...")
razorpay = razorpay_agentic.Client(api_key="rzp_live_...")
# Define tools for Claude
tools = [
{
"name": "get_last_order",
"description": "Retrieve the user's last order from a merchant",
"input_schema": {
"type": "object",
"properties": {
"merchant": {"type": "string", "enum": ["zepto", "swiggy", "blinkit"]},
"user_id": {"type": "string"}
},
"required": ["merchant", "user_id"]
}
},
{
"name": "initiate_reorder",
"description": "Place a reorder using the user's pre-authorized spending limit",
"input_schema": {
"type": "object",
"properties": {
"order_id": {"type": "string"},
"max_amount": {"type": "number"},
"upi_reserve_token": {"type": "string"}
},
"required": ["order_id", "max_amount", "upi_reserve_token"]
}
}
]
def handle_tool_call(tool_name: str, tool_input: dict) -> str:
if tool_name == "get_last_order":
# Call Zepto/Swiggy API to fetch last order
return fetch_last_order(tool_input["merchant"], tool_input["user_id"])
elif tool_name == "initiate_reorder":
result = razorpay.agentic_pay(
order_id=tool_input["order_id"],
amount=tool_input["max_amount"],
reserve_token=tool_input["upi_reserve_token"]
)
return f"Order placed. Transaction ID: {result.transaction_id}, Amount: ₹{result.amount}"
def grocery_agent(user_message: str, user_id: str, upi_reserve_token: str):
messages = [{"role": "user", "content": user_message}]
system = f"""You are a grocery assistant for user {user_id}.
The user has authorized you to spend up to ₹800 per reorder via UPI Reserve Pay.
Their token: {upi_reserve_token}
Only initiate payments when explicitly requested or when a scheduled reorder is due.
Always confirm the order contents before initiating payment."""
while True:
response = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=1024,
system=system,
tools=tools,
messages=messages
)
if response.stop_reason == "end_turn":
return response.content[0].text
if response.stop_reason == "tool_use":
tool_results = []
for block in response.content:
if block.type == "tool_use":
result = handle_tool_call(block.name, block.input)
tool_results.append({
"type": "tool_result",
"tool_use_id": block.id,
"content": result
})
messages.append({"role": "assistant", "content": response.content})
messages.append({"role": "user", "content": tool_results})
# Usage
response = grocery_agent(
"Reorder my usual Zepto basket. Keep it under ₹800.",
user_id="user_12345",
upi_reserve_token="upi_reserve_abc123"
)
print(response)
The agent loop follows the ReAct pattern: reason about what's needed, call a tool, observe the result, reason again. For this use case, the reasoning is light — get last order, confirm contents, initiate payment. But the same architecture scales to more complex decisions: comparing prices across merchants, checking if items are in stock, applying available coupons.
💡 Want to access Claude API in India with INR billing while you build? AICredits.in provides Claude API access with UPI payment — no international card needed.
The bigger picture
India is about to leapfrog the West in agentic commerce, for the same reason it leapfrogged in mobile payments. The West built payments infrastructure on a credit-card model that's expensive to integrate, slow to settle, and friction-heavy for small transactions. India built UPI: instant settlement, zero MDR for small merchants, open API.
Agentic payments on top of UPI isn't an incremental improvement. It's the natural end state of a payments system that was always designed for programmability. The question for developers isn't whether this happens — it's whether you're positioned to build on it when the SDK becomes generally available.
The patterns are learnable now. The AI agents fundamentals, function calling, and consent architecture decisions you make in your current projects will carry directly into production-grade agentic payment systems.
Next steps
- What is an AI agent — the fundamental concepts behind the agentic architecture this post describes
- Function calling lesson — how Claude uses tools to interact with external systems (the core primitive for agentic payments)
- Build your first AI agent — a hands-on tutorial to get you from zero to a working agent
- AICredits.in review — how to access Claude API today with INR billing and UPI payment
