Listen to this Post
Introduction:
The e-commerce landscape is undergoing a fundamental architectural shift. While traditional search traffic converts at baseline rates, Adobe’s Q1 2026 dataset—covering over one trillion US retail site visits—reveals that AI-referred shoppers convert 42% better and return 69% less often than visitors from other channels. This isn’t incremental improvement; it’s a paradigm change. Salesforce quantified AI-influenced global online sales during Cyber Week at approximately $67 billion, representing close to 20% of all digital orders. With McKinsey projecting agentic AI will influence $3–5 trillion in global retail by 2030, the question is no longer if merchants should prepare for AI agents, but how to build the secure, scalable infrastructure required to capture this opportunity—especially in late-to-digital categories like fine jewelry, where the first-mover advantage remains substantial.
Learning Objectives:
- Understand the three-layer architecture (Communication, Merchant Journey, Settlement) powering agentic commerce and the distinct role of each protocol
- Implement secure API authentication and encryption using JWS+JWE standards with practical OpenSSL commands
- Deploy a production-ready ACP (Agentic Commerce Protocol) checkout gateway using serverless architecture
- Configure rate limiting, token scoping, and OAuth 2.0 to prevent AI agent abuse and credential exposure
- Audit your site’s AI-readiness using practical Linux commands and structured data validation techniques
You Should Know:
- The Agentic Commerce Protocol Stack: MCP, ACP, and UCP Explained
Agentic commerce doesn’t run on a single protocol—it runs on a layered stack where each standard solves a specific problem. Understanding this stack is the difference between treating “agentic payments” as a buzzword and actually building for it.
The Model Context Protocol (MCP) , originally from Anthropic, is the discovery and tool layer. It standardizes how AI agents securely connect to external data sources, tools, and APIs. In commerce, MCP lets an agent find a merchant’s catalogue and call its capabilities in a structured, machine-readable way. Most other protocols now assume MCP as the underlying data plane.
The Agentic Commerce Protocol (ACP) , co-developed by Stripe and OpenAI, handles the checkout layer. It gives merchants a small set of REST endpoints to create, update, complete, and cancel orders, using a scoped payment token. The protocol defines a four-party flow between a buyer, an AI agent, a business, and a payment provider.
The Universal Commerce Protocol (UCP) , co-developed with Shopify and backed by Walmart, Target, Wayfair, Etsy, Mastercard, and Visa, standardizes catalogue, cart, and order interactions. UCP supports three transport layers including MCP and defines exact callback sequences for shopping flows.
Step-by-Step: Deploy a Reference ACP Checkout Gateway
The NVIDIA AI Blueprints repository provides a production-ready reference implementation combining ACP and UCP. Here’s how to deploy it:
Clone the NVIDIA Retail Agentic Commerce repository
git clone https://github.com/NVIDIA-AI-Blueprints/Retail-Agentic-Commerce
cd Retail-Agentic-Commerce
Start the merchant API (Port 8000) and PSP service (Port 8001)
docker-compose up -d merchant-api psp-service
Verify the ACP endpoint is accessible
curl -X GET http://localhost:8000/.well-known/acp
Start the NAT agents (promotion, post-purchase, recommendation, search)
docker-compose up -d promo-agent post-agent recs-agent search-agent
The MCP server runs on Port 2091 - test the connection
curl -X POST http://localhost:2091/tools/call \
-H "Content-Type: application/json" \
-d '{"tool": "search-products", "params": {"query": "engagement ring"}}'
For a lighter implementation, the nekuda-ai ACP-Checkout-Gateway provides a serverless reference you can deploy in minutes:
Clone and deploy via AWS SAM git clone https://github.com/nekuda-ai/ACP-Checkout-Gateway cd acp-checkout-manager npm install Set required environment variables export SESSION_HISTORY_TABLE="acp-checkout-dev-sessions" export IDEMPOTENCY_TABLE="acp-checkout-dev-created-sessions" export MERCHANT_TERMS_OF_USE_URL="https://yourdomain.com/terms" Start local development server npm run dev Deploy to AWS Lambda cd infra && sam build && sam deploy --guided
The gateway enforces idempotency, verifies cryptographic signatures, handles authentication, retries, and input validation—all essential for production-grade agentic checkout.
2. Cryptographic Trust: Authenticating AI Agents with JWS+JWE
Security is the critical enabler of agentic commerce. Visa’s Trusted Agent Protocol (TAP) establishes a cryptographic trust framework enabling merchants to verify the authenticity, intent, and authorization of AI shopping agents. Once authenticated, the merchant can safely expose APIs while distinguishing legitimate agentic activity from fraud attempts.
The Forter Trusted Agentic Commerce Protocol relies on JWS+JWE Security—JWT signatures (JWS) wrapped in JSON Web Encryption (JWE) for both authentication and confidentiality. Here’s how to implement this trust layer:
Generate RSA Keys for Agent Authentication
Generate 3072-bit RSA key pair (recommended for long-term security) openssl genpkey -algorithm RSA -out private.pem -pkeyopt rsa_keygen_bits:3072 openssl rsa -in private.pem -pubout -out public.pem For legacy compatibility only (2048-bit minimum) openssl genpkey -algorithm RSA -out private.pem -pkeyopt rsa_keygen_bits:2048
Extract Values for JWKS Publishing
Extract modulus (n) - base64url encoded openssl rsa -in public.pem -pubin -modulus -1oout | \ cut -d'=' -f2 | xxd -r -p | base64 | tr -d '=\n' | tr '/+' '_-' Generate key ID (kid) - SHA-256 hash of public key openssl rsa -in public.pem -pubin -outform DER 2>/dev/null | \ openssl dgst -sha256 -binary | base64 | tr -d '=' | tr '/+' '_-'
Publish Your JWKS Endpoint
Publish public keys at `https://your-domain.com/.well-known/jwks.json`:
{
"keys": [
{
"kty": "RSA",
"n": "<output from modulus extraction>",
"e": "AQAB",
"alg": "RS256",
"kid": "<output from kid generation>"
}
]
}
Security Note: For long-term security, use 3072-bit or 4096-bit RSA keys. Always use HTTPS in production for JWKS endpoints.
- API Security Hardening: Scoped Tokens, OAuth, and Rate Limiting
Connecting an AI agent to your commerce platform gives it the ability to read, create, update, and delete resources. The risk surface varies by server type, and understanding these differences is your starting point.
Step-by-Step: Implement Scoped API Credentials
Never use your personal admin token or broad integration credentials as the MCP token. Create dedicated API credentials for MCP use via the Provisioning API or directly in your dashboard:
Example: Create a read-only agent token via API
curl -X POST https://your-commerce-layer.com/api/oauth/token \
-H "Content-Type: application/json" \
-d '{
"grant_type": "client_credentials",
"client_id": "your-client-id",
"client_secret": "your-client-secret",
"scope": "read:products read:analytics"
}'
Configure Granular Access Control with Roles
| Agent Scope | Permissions | Recommended Use |
|-|-|–|
| Read-only agents | Analytics, reporting, Q&A | Product discovery, price comparison |
| Content creators | Draft orders, SKUs | Build carts, generate product drafts |
| Full CRUD agents | Create, update, delete resources | Order management, inventory updates |
Prefer OAuth 2.0 Over Static Tokens
When using Claude Desktop, ChatGPT, or another client that supports OAuth 2.0, use that flow instead of pasting a bearer token into the config. OAuth tokens are short-lived and tied to an authorization session. A static Bearer token can sit in a config file indefinitely and be accidentally committed to a repository.
Implement Token-Based Rate Limiting
ClicShopping’s AI security framework organizes protection into 10 independent layers, including rate limiting with window-based request quotas:
Nginx rate limiting configuration for AI endpoints
limit_req_zone $binary_remote_addr zone=ai_api:10m rate=20r/900s;
location /api/acp/ {
limit_req zone=ai_api burst=5 nodelay;
limit_req_status 429;
proxy_pass http://acp-gateway;
}
- Agentic Commerce Readiness: Visibility, Detection, and Policy Enforcement
AI agent traffic has moved from edge case to operational reality. DataDome’s Global Bot Security Report showed a fourfold increase in AI traffic between January and August 2025, with 65% of that traffic hitting form pages, 23% targeting login pages, and 5% reaching checkout. The practical questions most teams can’t afford to treat as theoretical:
Audit Your Site’s AI Readiness
Check if your site is being crawled by AI agents
grep -i "perplexity|chatgpt|gemini|claude|agent" /var/log/nginx/access.log | \
awk '{print $1, $7, $12}' | sort | uniq -c | sort -1r
Verify robots.txt allows legitimate AI agents
curl -s https://yourdomain.com/robots.txt | grep -E "User-agent|Allow|Disallow"
Audit structured data for AI readability
curl -s https://yourdomain.com/product/engagement-ring | \
grep -E 'application/ld+json|Product|offers|price'
Action Checklist for Leadership:
- Visibility: Can you identify which specific AI agents are accessing your site, not just that you see agent traffic?
- Intent: Can you distinguish between commercial/user-driven agents and harmful scrapers, fraud, or abuse?
- Policy: Do you have a documented AI agent access policy defining what you allow, what you block, and under what conditions?
- Enforcement: Can you technically enforce your policies (block, rate-limit, authenticate) consistently?
Block Untrusted AI Agents
For merchants wanting to control which agents access their site, here’s how to identify and block specific agents:
Identify Perplexity Shopper traffic patterns
Perplexity loads your site in a real browser, navigates your catalogue, and completes purchases
A human completing checkout averages 6 minutes with 23 distinct input events on the payment form
Block in nginx by user-agent
if ($http_user_agent ~ "Perplexity|ChatGPT|Gemini|Claude") {
return 403;
}
Block at application level (Node.js/Express)
const blockedAgents = ['Perplexity', 'ChatGPT', 'Gemini'];
app.use((req, res, next) => {
const ua = req.headers['user-agent'] || '';
if (blockedAgents.some(agent => ua.includes(agent))) {
return res.status(403).json({ error: 'AI agent access denied' });
}
next();
});
5. Cloud Hardening for Agentic Commerce Workloads
As organizations move from basic chatbots to autonomous shopping assistants, the challenge lies in maintaining security and cost governance at scale. Google Cloud’s Apigee X acts as a critical “Trust Layer” to manage retail AI agents from product discovery to final purchase.
Implement a Trust Layer with API Gateway
Deploy Apigee X proxy configuration Use Model Armor to proactively filter unsafe content and prevent prompt injections Token-based rate limiting and usage quotas Ensure AI initiatives remain cost-effective and performant at scale Example: Kong Gateway rate limiting for AI endpoints curl -X POST http://localhost:8001/services/ai-service/plugins \ -d "name=rate-limiting" \ -d "config.minute=100" \ -d "config.hour=1000"
AWS Infrastructure for Agentic Commerce
AWS launched an AI shopping assistant service built on Amazon Bedrock AgentCore, with infrastructure supporting authentication and performance monitoring. The stack includes Amazon Bedrock, AgentCore, and OpenSearch.
Deploy AWS Bedrock AgentCore aws bedrock-agent create-agent \ --agent-1ame "jewelry-shopping-assistant" \ --foundation-model "anthropic.claude-3-haiku-20240307-v1:0" \ --instruction "You are a fine jewelry shopping assistant" \ --agent-resource-role-arn "arn:aws:iam::account:role/AgentRole" Configure OpenSearch for product discovery aws opensearch create-domain \ --domain-1ame "jewelry-catalog" \ --engine-version "OpenSearch_2.11" \ --cluster-config InstanceType="t3.medium.elasticsearch",InstanceCount=1
- Data Governance and Compliance for AI Agent Interactions
If agents are interacting with your site and potentially with user-specific flows, your public-facing language and internal governance need to reflect that reality. McKinsey’s research highlights that the transition introduces new technical and operational challenges, including the need for agent-ready APIs, robust data governance, and new standards for trust and compliance.
Audit Your Product Data for AI Readability
AI systems like ChatGPT and Perplexity don’t crawl websites like classical search engines—they prefer structured, machine-readable data. Adobe reports that one third of retailer content cannot be read by AI agents at all.
Audit your top 10 products for structured data
for product in $(curl -s https://yourdomain.com/api/products | jq -r '.[0:10].id'); do
curl -s https://yourdomain.com/api/products/${product} | \
jq '. | {id, name, description, price, availability, @context, @type}'
done
Validate JSON-LD structured data
curl -s https://yourdomain.com/product/engagement-ring | \
grep -A 20 'application/ld+json' | jq '.'
Configure robots.txt for AI Agents
robots.txt - Allow legitimate AI shopping agents User-agent: Perplexity Allow: /products/ Allow: /api/catalog User-agent: ChatGPT-User Allow: /products/ Allow: /api/catalog User-agent: Google-Extended Allow: /products/ Allow: /api/catalog Block malicious or unwanted scrapers User-agent: Disallow: /admin/ Disallow: /checkout/ Disallow: /api/private/
What Undercode Say:
- The protocol stack is the new competitive moat: Merchants who implement MCP, ACP, and UCP today will have a structural advantage over those waiting for “market maturity.” The protocols are open, industry-backed, and production-ready. The fine jewelry sector—where 80% of purchases still close offline—represents a greenfield opportunity where early adopters can define the standards.
-
Security is not a barrier; it’s the enabler: The cryptographic frameworks (JWS+JWE, TAP, OAuth) are well-established and deployable today. The real challenge isn’t technical implementation—it’s organizational readiness to create dedicated, scoped credentials and enforce rate limiting. Merchants who treat security as a compliance checkbox rather than an architectural foundation will be the ones exploited.
Analysis: The data from Adobe (42% better conversion, 69% lower returns) and Salesforce ($67 billion in AI-influenced sales) isn’t hypothetical—it’s measurable reality. The protocols (MCP, ACP, UCP) went from nonexistent to industry-backed in approximately eighteen months, a pace that mirrors the early days of cloud adoption. For late-to-digital categories like fine jewelry, being “late to digital” means being “early to this”. The infrastructure components—cryptographic authentication, rate-limited APIs, scoped tokens, structured data—are all available and deployable today. The bottleneck is organizational inertia, not technical capability. Merchants who deploy ACP gateways, implement JWKS endpoints, and audit their product feeds for AI readability will capture the agentic commerce wave; those who wait for “clarity” will be disrupted by those who act.
Prediction:
- +1 Agentic commerce will follow the SaaS adoption curve—slow initial uptake followed by explosive growth. By 2028, the majority of digital-1ative retailers will have deployed ACP or UCP gateways, with the jewelry sector (high-value, high-touch) emerging as a key vertical for agent-mediated purchases due to the trust required and the research-intensive nature of the purchase.
-
+1 The protocol layer (MCP/ACP/UCP) will consolidate around a de facto standard within 24 months, similar to how REST and GraphQL emerged. Early adopters who implement multiple protocols will have the flexibility to adapt without replatforming.
-
-1 Security incidents involving AI agents—credential theft, unauthorized purchases, prompt injection—will spike in 2027-2028 as malicious actors target poorly secured agentic commerce endpoints. Merchants who rely on static tokens and broad admin credentials will be the primary victims.
-
-1 The “AI readiness gap”—the difference between merchants who have structured, machine-readable product data and those who don’t—will widen. Adobe’s finding that one-third of retailer content is invisible to AI agents suggests a significant competitive disadvantage for unprepared merchants.
-
+1 The $3-5 trillion McKinsey projection is conservative. As agentic protocols mature and consumer trust increases, the actual figure could exceed $6 trillion by 2032, particularly as the “80% offline” categories like fine jewelry—currently underrepresented in e-commerce—transition to agent-mediated channels.
▶️ Related Video (76% Match):
https://www.youtube.com/watch?v=1rDPXbF04nA
🎯Let’s Practice For Free:
🎓 Live Courses & Certifications:
Join Undercode Academy for Verified Certifications
🚀 Request a Custom Project:
Secure, high-velocity infrastructure and disruptive technological engineering. Contact our engineering team for high-tier development and proprietary systems:
[email protected]
💎 Smart Architecture | 🛡️ Secure by Design | ⭐ Trusted by Thousands
IT/Security Reporter URL:
Reported By: Sergiu Costin – Hackers Feeds
Extra Hub: Undercode MoN
Basic Verification: Pass ✅
