AI Agents are now loyalty members: what UCP means for incentives

It’s barely 2026 and AI agents are already applying promo codes, redeeming loyalty points, and skipping your UI entirely.

Thanks to Google’s new Universal Commerce Protocol (UCP), agents like Gemini can now plug directly into a merchant’s backend, no screen scraping, no browser extensions. Discovery, identity, checkout? All standardized. And now, incentives are officially part of that spec.

Loyalty and promotions just became protocol-level features. If your stack can’t expose them in a structured way, good luck showing up.

This post breaks down how UCP actually works, where incentives fit in, and what it means if you run loyalty, promotions, or the infra that powers them.

Spoiler: your discounts might need a schema.

The AI commerce shift (it's already here)

Let’s get this out of the way: agentic commerce sounds like a made-up term. But what it really means is simple: AI tools are now acting on behalf of customers.

And not just to recommend products. They’re:

• Finding what matches intent
• Evaluating trade-offs (shipping, value, reviews)
• Linking identity (loyalty)
• Checking out

That’s a big shift. Because until now, incentives were something you presented. A banner, a code box, a loyalty widget. Now, they’re something your system needs to communicate in real time, to a non-human interface.

Google isn’t building this in isolation. UCP is co-developed with Shopify and tested with brands like Petco, e.l.f., and Rugs USA. Gemini’s AI Mode is already surfacing deals mid-search. And with Direct Offers, advertisers can preload exclusive discounts that AI shows only when the shopper seems ready to buy.

So if you’ve been treating incentives like static, UI-tied objects, some JavaScript and a CMS block, you might already be invisible to the new interface.

What UCP really does (and what it means for incentives)?

UCP (Universal Commerce Protocol) is an open standard that lets agents, like Google’s Gemini, interact with commerce systems in a structured, predictable way. It’s like giving AI a universal API spec to browse, personalize, and transact across merchants.

It’s a manifest, some endpoints, and a set of capabilities that businesses can expose. And those capabilities? They now include discounts and loyalty.

UCP defines six base capabilities, which are basically opt-in modules a business can expose:

• Product discovery
• Cart management
• Checkout (this is where discounts live)
• Identity linking (this is where loyalty & personalized promos live)
• Fulfillment
• Order status

Each capability has optional Extensions, which let businesses add extra context or behavior. This is where incentives show up.

Discounts are an extension of the Checkout Capability, while loyalty (or rewards tied to customer identity) becomes possible via the Identity Linking Capability.

This structure is key. It means incentives aren’t just UI layers, they’re declared functions that agents can detect, call, and understand.

UCP Discounts: what it covers?

When a business supports the Discount Extension, they expose structured logic around:

• Discount types (percentage, fixed amount, shipping)
• Scope (item, cart, shipping)
• Application method (automatic or coupon code)
• Stacking rules (whether discounts can combine)
• Eligibility rejection reasons (e.g. expired, ineligible, already used)
• Messaging (what to display to the user if a discount is rejected)

The agent doesn’t guess. It asks: “What discounts are valid for this session/cart?” And the business responds with machine-readable info the agent can apply.

UCP Identity Linking: what it covers?

This is where it gets more interesting for loyalty programs. The Identity Linking Capability lets an agent authenticate a user against a merchant’s backend. Like sign in with Google or token-based login.

Once linked, the agent can:

• Fetch loyalty balance
• Apply eligible rewards
• Trigger new earn events
• Personalize offers based on status, tier, or point history

This turns loyalty from a separate program you check after login to something agents use during product discovery or checkout to enhance relevance and value.

How the UCP works?

Here’s how the UCP actually works:

• Business publishes a manifest at a known URL (/.well-known/ucp). This declares which capabilities and extensions are supported. 
• Agent reads this manifest to discover available functions.
• Agent calls standard endpoints to create sessions, build carts, link identity, apply discounts.
• Business responds with structured commerce state: cart total, discounts applied, loyalty balance, etc.

This creates a two-way dialogue between agent and business systems with discounts and loyalty built in as structured, real-time hooks.

Compare that to the traditional model, where:

• Discounts are hardcoded into templates.
• Loyalty lives in a siloed system or app.
• Stack integration is ad hoc, not spec-driven.

UCP flips this. Now incentives are part of the protocol itself. If you don’t expose them, you’re not part of the conversation.

What UCP enables and what it breaks?

If you’re running a loyalty program or discount logic today, this changes what integration means. Because it’s not just about sending the right offer, it’s about making that offer visible and usable to an agent. In real time.

Let’s start with what’s possible now that discounts and loyalty are part of the protocol:

• Agent-discoverable discounts: Agents can now surface current, stackable, and personalized discounts before the user lands on your site. 
• Loyalty redemption at checkout via agent: Once a user is identity-linked, agents can show earned rewards, apply them automatically to the cart, and explain eligibility or rejection.
• Dynamic incentive recommendations: Agents can factor loyalty status or discount eligibility into product selection itself. For example: “Show me the best vacuum under $300 that gets me the most points at checkout.”
• Offer explanation & transparency: UCP’s response model includes messaging: “Why this discount applied,” “Why it didn’t,” “What else you could qualify for.” This turns incentives into explainable ranking factors, not hidden perks.

What breaks (for most teams)?

This all sounds powerful, because it is. But here’s what breaks if your system wasn’t built for it:

• Frontend-only logic: If your discounts or loyalty logic only exist in JS, templates, or CMS… agents can’t see them. They need to be exposed via structured APIs that align with UCP’s schema.
• Siloed loyalty platforms: Many loyalty platforms are closed off, require UI integration, or don’t support real-time redemption. UCP assumes your systems can make eligibility and balance decisions on request.
• Static discount systems: Legacy promo engines often require full redeploys or manual entry to update offers. UCP demands instant responses to dynamic carts and customer context.
• No concept of customer identity: Without proper Identity Linking support, you’re locked out of loyalty use cases. The agent can’t pull history, apply earned rewards, or personalize offers.

Summary

AI agents are rapidly evolving into loyalty members, price shoppers, and checkout bots, but they can only engage if your incentive infrastructure is ready. That means incentives must be structured, API-accessible, identity-aware, and operate in real time. The major players, Google, Microsoft, OpenAI,  are already moving fast, embedding checkout and shopping capabilities directly into their AI tools.

If your loyalty or promo engine can’t do that, it’s not ready for agentic commerce.