Adobe Commerce and Agentic Commerce: What Magento Merchants Need to Know in 2026

Adobe Commerce does not have native UCP support, and Adobe has not committed to a public timeline for adding it. For the 8,000+ enterprise brands running on Adobe Commerce, this creates an immediate strategic decision: wait for platform support, or build agent readiness now through Magento’s proven extension architecture.

Adobe is investing heavily in AI — Adobe Sensei, AI-powered personalization, the Commerce Optimizer suite. The platform is evolving fast. But Universal Commerce Protocol, the open standard that lets AI shopping agents discover and transact with your store, is not on Adobe’s official roadmap, at least not publicly.

Why Adobe Commerce Is Actually Well-Positioned

Before addressing the gap, it’s worth naming the advantages.

GraphQL-first architecture. Adobe Commerce’s comprehensive GraphQL API is one of the most complete in enterprise commerce. Every product, category, pricing rule, inventory signal, and cart operation is queryable via a well-documented schema. AI agents need clean, structured API access — and Adobe Commerce’s GraphQL layer is already structured for programmatic consumption.

PWA Studio and headless patterns. Many Adobe Commerce merchants have already adopted headless or composable architectures through PWA Studio or custom frontends. This decoupled pattern makes it significantly easier to add agent-facing endpoints without disturbing the storefront.

Extension ecosystem maturity. The Magento marketplace has 3,000+ extensions, and the extension architecture is deeply understood by the developer community. Adding protocol support through extensions is a proven pattern — not an architectural experiment.

Multi-store, multi-brand, multi-region. Adobe Commerce’s multi-store capabilities are enterprise-grade. For brands operating multiple storefronts — different brands, different regions, different B2B catalogs — the platform’s native architecture supports deploying per-store agent configuration with shared infrastructure.

The platform can support agentic commerce. It just needs the protocol layer that Adobe hasn’t shipped yet.

The Waiting Risk

The temptation is to wait for Adobe to ship native UCP support. After all, platform-native implementations are typically lower-maintenance than extension-based approaches.

But “waiting for the platform” carries real costs.

Timeline uncertainty. Adobe hasn’t announced UCP support, and enterprise platform roadmaps move slowly. “Next year” can mean 18 months. That’s 18 months of Google AI Mode, ChatGPT Shopping, and enterprise procurement agents surfacing competitors — not you.

Optimization lag. Even when Adobe ships native UCP, turning it on is a starting point, not a destination. GEO optimization, product data enrichment, discovery manifest configuration, and protocol testing all take time. Brands that start now will be 12–18 months ahead on the optimization curve when native support arrives.

Competitive compounding. AI agent recommendation systems learn from performance data. Brands that are recommended now and convert well get recommended more. The recommendation advantage compounds with time in the market. Every month of delay is a month of compounding your competitors are doing without you.

The math is clear: waiting for native support is the more expensive option.

What Extension-Based Implementation Actually Looks Like

Adobe Commerce’s extension architecture supports adding protocol capabilities without core code modifications. A well-designed implementation:

Protocol Extensions

UCP, MCP, and A2A can be delivered as Composer-managed modules that:

• Add new API endpoints for agent discovery and transaction
• Implement the session lifecycle (discovery → selection → checkout → fulfillment)
• Handle protocol-specific authentication and trust verification
• Log agent interactions separately from storefront traffic for measurement

These modules hook into Adobe Commerce’s existing catalog, pricing, inventory, and checkout layers — they don’t replace them. Your existing catalog management, pricing rules, and order processing continue to work exactly as they do today.

GEO and Structured Data

Adobe Commerce’s built-in schema generation and meta management can be extended to produce the richer, more complete structured data that GEO requires:

• Full Product schema with all attributes, not just name/price/SKU
• ShippingDetails and MerchantReturnPolicy schema
• AggregateRating markup properly formatted for AI consumption
• Availability by store/region for multi-store deployments

This is primarily a configuration and data quality problem, not an architectural one. If your product data is complete, the structured data layer can be built quickly.

Discovery Manifest

A UCP discovery manifest is the entry point for agent protocols — the document that tells AI systems what you sell, how to query it, and what capabilities you support for agent transactions.

For Adobe Commerce, the manifest is generated dynamically from your catalog configuration and exposed at a predictable URL. It requires no storefront changes and no customer-facing UI work.

The B2B Opportunity Is Bigger Than Most Teams Realize

Many Adobe Commerce deployments run B2B storefronts — wholesale portals, account-based pricing, contract catalogs. This is where the MCP and A2A protocol opportunity is particularly significant.

Enterprise buyers are deploying AI procurement systems right now. These systems use MCP to access supplier catalogs, query pricing for their account tier, check availability, and initiate orders against pre-approved purchasing policies — autonomously, without human involvement in each transaction.

If your B2B catalog isn’t MCP-accessible, you’re invisible to those systems. Your competitors who implement MCP first will receive automated orders from enterprise AI procurement tools that never visit your portal.

For high-frequency B2B relationships, A2A enables fully automated order workflows: the buyer’s agent and your supplier agent negotiate terms, validate against purchasing policy, and complete the transaction without a human approving each order.

This is not science fiction. It’s in production at select enterprise suppliers today.

The Product Data Problem You Need to Solve First

Here’s the honest assessment: for most Adobe Commerce merchants, the protocol implementation is not the hardest part. The product data is.

AI agents can only recommend products they can evaluate. If your catalog has:

• Attributes named inconsistently across categories
• Missing specifications on a significant portion of SKUs
• Pricing that’s stale or inconsistent between systems
• Images without proper alt text or structured metadata
• Product descriptions that are marketing copy, not structured attribute data

…then adding UCP to your platform doesn’t solve your agent invisibility problem. It just makes a structurally incomplete catalog accessible via a protocol.

The right approach is to audit and fix your product data in parallel with protocol implementation — or even first. For a typical mid-size Adobe Commerce deployment, a data quality audit surfaces gaps on 20–40% of active SKUs. Fixing those gaps delivers GEO improvements immediately, before a single line of protocol code ships.

How to Sequence an Adobe Commerce Agentic Implementation

Given the above, here’s the sequencing we recommend:

Phase 1 (Weeks 1–4): Audit and Prioritize

• Product data quality audit across top catalog segments
• Structured data and schema gap analysis
• API readiness assessment (GraphQL coverage, rate limiting, authentication)
• B2B buyer analysis: which accounts could benefit from MCP/A2A?

Phase 2 (Weeks 5–10): Foundation

• Fix critical product data gaps in priority categories
• Implement comprehensive Schema.org markup
• Deploy updated Google Merchant Center feeds
• Set up agent traffic measurement

Phase 3 (Weeks 8–14): Protocol Layer

• Install and configure UCP extension
• Configure discovery manifest for primary catalog
• Test agent discovery and checkout flows
• Launch to production with monitoring

Phase 4 (Ongoing): B2B Protocols and Optimization

• MCP server for enterprise buyer access
• A2A for qualified high-frequency accounts
• Continuous GEO optimization based on performance data

The timeline for a typical Adobe Commerce implementation is 8–14 weeks to full protocol readiness, assuming product data and API infrastructure are in reasonable shape.

What to Do This Quarter

If you’re an Adobe Commerce merchant evaluating this space, the decision framework is simple:

1. Don’t wait for Adobe. The competitive window is open now. Extension-based implementation is proven and production-ready.

2. Start with data. Run an honest audit of your product data quality before investing in protocol infrastructure. Data gaps are the most common reason implementations underdeliver.

3. Prioritize by business model. B2C with high-frequency repeat products → UCP first. B2B with enterprise accounts → MCP alongside UCP. High-volume wholesale relationships → A2A.

4. Measure from day one. Instrument agent traffic separately, track recommendation rates, and set conversion baselines before you optimize.

The brands building agentic infrastructure on Adobe Commerce in the next two quarters will have a head start that’s difficult to overcome once the mainstream catches up.

---

Running Adobe Commerce and want to know your agentic readiness score? Take the free assessment or speak with our team about an Adobe Commerce implementation roadmap.