The Identity and Audit Layer for Google's Universal Commerce Protocol (UCP)

Agents Can Now Buy Across the Web. Who Verifies Them?

Google launched the Universal Commerce Protocol (UCP) at NRF in January 2026 and expanded it at Google Marketing Live. It is an open, vendor-neutral standard for agentic commerce: an AI agent can discover products, create a checkout session, complete a purchase, and manage the order, across any merchant that speaks the protocol. It runs over REST and JSON-RPC, with A2A and MCP bindings, and supports cryptographic payment proofs through the Agent Payments Protocol (AP2). Shopify, Etsy, Target, Walmart, and Wayfair are on board, with payment and card networks behind it.

This is genuinely the rails for the agent economy. But it leaves one question open, the same one we keep coming back to: when an agent creates a checkout for someone else's money, who verifies the agent itself?

UCP standardises the transaction. It does not answer: is this the agent it claims to be, is it allowed to spend on this merchant for this amount, and can the merchant, the customer, or a regulator later prove what this specific agent did, without taking the platform's word for it?

That is the layer Vorim adds. UCP is built on A2A and MCP, both of which we already integrate, so Vorim rides the same rails.

How It Works

Before an agent initiates a UCP checkout, the Vorim integration runs three checks in sequence:

1. Permission check: Does this agent hold the agent:transact scope? That is an explicit grant from the organisation that deployed it. Without it, the agent is blocked before it ever reaches the merchant.

2. Trust score check: What is the agent's live behavioural trust score? A consistent, low-denial agent passes; an erratic one is blocked. The threshold is configurable.

3. Status check: Is the agent currently active? Suspended or revoked agents are blocked regardless of permissions or score.

If all three pass, the checkout proceeds and a signed success event is recorded. If any fail, the purchase is blocked and a signed denial event is recorded with the specific reason.

TypeScript

import createVorim from '@vorim/sdk';
import { createVorimUCP } from '@vorim/sdk/integrations/ucp';

const vorim = createVorim({ apiKey: 'agid_sk_...' });
const ucp = createVorimUCP(vorim, { minTrustScore: 70 });

// Before an agent initiates a UCP checkout
const auth = await ucp.authorizePurchase({
  agentId: 'agid_abc123',
  merchant: 'acme-store',
  amount: 4999,
  currency: 'usd',
});

if (auth.authorized) {
  // ...run the UCP checkout, then record the signed audit trail:
  await ucp.logOrderPlaced('agid_abc123', ucpOrderId, 'acme-store', 4999);
} else {
  console.log('Blocked:', auth.reason);
}

Express Middleware

// Agent must send the X-Vorim-Agent-Id header
app.post('/ucp/checkout',
  ucp.middleware({ minTrustScore: 70 }),
  (req, res) => {
    // Only reached if the agent is verified
    const { trustScore, status } = req.vorimAuthorization;
    // Create the UCP checkout session...
  }
);

Python

from vorim.ucp import VorimUCP

ucp = VorimUCP(api_key='agid_sk_...', min_trust_score=70)

result = ucp.authorize_purchase(
    agent_id='agid_abc123',
    merchant='acme-store',
    amount=4999,
    currency='usd',
)

if result['authorized']:
    ucp.log_order_placed('agid_abc123', ucp_order_id, 'acme-store', 4999)

# Flask/FastAPI decorator
@ucp.require_transact()
def create_checkout(request):
    return process_checkout(request)

The Audit Trail, and AP2

Every step of the UCP lifecycle is recorded to Vorim's signed, offline-verifiable audit trail:

That last one matters. UCP's ap2_mandate extension carries a signed checkout_mandate (a JWT) that proves the agent was authorised to pay. Vorim captures it in the audit record, so UCP's own cryptographic payment proof is linked to a Vorim-signed record of the action that anyone can verify independently, with Vorim nowhere in the trust path.

And requires_escalation is not a dead end. It is the natural hand-off point: a high-stakes UCP checkout can be held for human approval through Vorim runtime control before it completes.

Why This Matters

Agentic commerce is arriving fast. Google's UCP, OpenAI's and Stripe's ACP, AP2, all live or launching, across millions of merchants. The transaction layer is being standardised in the open, which is exactly right.

But commerce without identity is a fraud vector. You would not let an unidentified person charge thousands to someone else's card; an unidentified agent should not initiate purchases without proof of who it is, what it is allowed to do, and a record a counterparty can verify. UCP handles how the agent and merchant transact. Vorim handles which agent it is, whether it is allowed, and the evidence afterward.

Get Started

# TypeScript
npm install @vorim/sdk

# Python
pip install vorim

Full documentation: vorim.ai/docs Integrations page: vorim.ai/integrations

If you're building on UCP and want to add agent identity verification and a verifiable audit trail, reach out at team@vorim.ai or book a call at vorim.ai/contact.

Ready to build with agent identity?

Free plan: 3 agents, 10K auth events/month, full SDK access. No credit card.