UCP for Subscription Billing: How Recurring Commerce Works with AI Agents

The Subscription Commerce Problem

Standard UCP checkout is built around discrete purchases: agent selects a product, agent pays, merchant ships. Subscription billing does not fit this model cleanly. A subscription has state that persists between transactions. The agent needs to know what is active, when it renews, what plans are available, and how to change them.

This matters for developers building agents that manage software or media subscriptions for users. The subscription lifecycle includes trial activation, plan upgrades, renewal handling, cancellation, and reactivation. An agent that can only initiate checkout cannot handle most of these steps.

UCP's subscription capability layer addresses this. It extends the base spec with subscription-aware endpoints on top of the standard checkout flow.

How UCP Models Subscription State

A UCP-enabled subscription platform exposes an additional endpoint at /ucp/subscriptions alongside the standard /ucp/checkout. This endpoint returns the current subscription state for an authenticated identity token:

{
  "subscriptions": [
    {
      "id": "sub_abc123",
      "planId": "professional-monthly",
      "status": "active",
      "currentPeriodEnd": "2026-07-22T00:00:00Z",
      "upcomingInvoice": {
        "amount": 4900,
        "currency": "USD",
        "dueDate": "2026-07-22T00:00:00Z"
      },
      "availableUpgrades": [
        { "planId": "business-monthly", "amount": 9900 }
      ]
    }
  ]
}

The agent can read this data and present it to the consumer without the consumer logging into a portal. It is the same data the subscription portal shows, exposed through the UCP identity token.

Initiating Subscription Changes

Subscription modifications flow through the standard UCP checkout endpoint with an action field:

const session = await fetch('https://app.example.com/ucp/checkout', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-UCP-Identity-Token': identityToken,
  },
  body: JSON.stringify({
    action: 'plan-change',
    subscriptionId: 'sub_abc123',
    targetPlanId: 'business-monthly',
    paymentToken: ucpPaymentToken,
  }),
}).then(r => r.json());

console.log(session.immediateCharge); // proration amount due now
console.log(session.newMonthlyAmount); // recurring charge going forward

The response includes proration data. If the consumer is mid-cycle on a $49/month plan and upgrades to $99/month, the checkout session returns the prorated charge for the remainder of the current billing period. The agent surfaces this to the consumer before confirming.

Dunning and Payment Recovery

Subscription renewals fail. Payment methods expire. Credit cards get replaced. When a renewal fails, the subscription enters a dunning state where the billing platform retries the charge on a schedule.

With UCP identity linking, an agent can intercept dunning events. The subscription platform notifies the agent platform when a renewal enters dunning. The agent surfaces a payment update prompt to the consumer. The consumer updates their payment method through the agent, and the dunning sequence resolves without the subscription lapsing.

// Agent handling a dunning notification from the subscription platform
async function handleDunningNotification(event: UcpDunningEvent) {
  const consumer = await resolveConsumerFromIdentityToken(event.identityToken);

  await agentPlatform.sendNotification(consumer.id, {
    message: `Your ${event.merchantName} renewal failed. Update your payment method to prevent cancellation.`,
    action: {
      type: 'update-payment',
      ucpEndpoint: event.merchantEndpoint,
    },
  });
}

This flow replaces the standard dunning email sequence with an agent-driven recovery the consumer can act on directly in their agent interface.

Which Platforms Support Subscription UCP

Several billing platforms are building UCP subscription support:

• Chargebee: Consumer and B2B SaaS subscriptions. Plan changes, coupon management, dunning recovery.
• Recurly: Media and SaaS subscriptions. Trial management, plan comparison, churn recovery.
• Paddle: B2B SaaS with merchant-of-record tax handling. Good for software vendors selling globally.
• Zuora: Enterprise subscriptions with complex contract amendment workflows.

None of these are live yet. All have announced UCP as part of their roadmap. The subscription capability layer is still being finalized in the UCP spec.

What to Build Now

If you are building a subscription management agent today, here is the practical path:

1. Use each platform's existing REST API directly. Chargebee, Recurly, and Paddle all have well-documented APIs.
2. Abstract the subscription management calls behind an interface. When UCP subscription endpoints go live, you can swap the implementation without changing the agent logic.
3. Watch the UCP spec repository for the subscription capability extension, currently in draft at ucp.dev.

The direction is clear. Subscription billing platforms are adding UCP endpoints. Agents that manage subscriptions will use those endpoints. The standardized model means a single agent implementation can manage subscriptions across Chargebee, Recurly, and Zuora without platform-specific code for each.