Does Core dna use AI Agents for eCommerce Translation?
Yes. Core dna features a sophisticated autonomous AI agent that goes beyond simple text translation and replacement.
Updated: June 30, 2026
AI & Emerging Tech
Yes. Core dna features a sophisticated autonomous AI agent that goes beyond simple text replacement.
Instead of just translating "strings," our agent understands the component-level logic of your pages. It instantly reconstitutes and rebuilds entire layouts in the target language, ensuring that design integrity, SEO metadata, and functional elements remain intact.
This automated process allows ecommerce managers to review and verify the fully rebuilt page before it goes live, combining the speed of AI with human-in-the-loop control.
Related Questions
An enterprise AI agent is a software actor that takes goals, plans actions, and calls tools against your production systems on its own initiative. The distinguishing trait is autonomy with consequence. Unlike a chatbot, an agent is doing work that changes state - updating records, dispatching workflows, calling APIs that move money or content or customers. Enterprise-grade means it operates inside the same identity, audit, and governance perimeter as the rest of your platform.
A chatbot answers. An agent acts. The chatbot lives in the conversation layer and hands off to a human or a workflow when something needs to happen. The agent owns the doing. That difference is why the governance model for agents looks more like the model for a privileged service account than like the model for a content surface.
MCP, the Model Context Protocol, is a standard for exposing tools to AI agents as a declarative surface. Instead of every agent integrating against every system through bespoke code, the system publishes its tools through MCP and the agent discovers and calls them through a single protocol. For enterprise rollouts, MCP matters because tool boundaries become enforceable. You grant an agent access to specific tools rather than to whole systems, and you can revoke access without rewriting the agent. Core dna's MCP server exposes 80+ tools across 400+ APIs, in production today.
In phases, with read-only first. The pattern that works is: prepare the environment with scoped identity and audit, validate the agent in discovery mode where it can plan but not write, promote it to governed execution with tight tool boundaries and rollback, then run it under continuous governance with a standing review cadence. The single most common failure mode is granting write access before discovery-mode validation is honestly complete.
With a standing governance group, a monthly cadence, and the audit log as the agenda. Governance covers tool-permission drift, new-tool onboarding, model changes, incident review, and retiring tools the agent no longer needs. The governance group needs representation from digital, platform, security, and risk - not just the team that built the agent.
By the four-phase exit criteria, not by the model's benchmark scores. The readiness signal is operational: scoped identity in place, audit captures intent, discovery-mode plans match human-operator plans, governed execution has run a representative volume of writes with zero unrecoverable actions, and a governance cadence is established and attended. If any of those is missing, the agent is not ready to scale, regardless of how the model performs in isolation.
Yes, through Core dna MCP. Describe the change in plain language and the platform makes it against the same rules your team uses in the admin, with approval, audit, and rollback built in. Draft a promo, model a margin scenario before it goes live, audit recent overrides, or update contract pricing at renewal, all from a prompt. It runs on a live MCP server with 80+ tools and 400+ APIs. No price or promo goes live until the assigned approver signs off.
Yes, because the structure governs it. The agent acts inside the exact permissions each person already has, reads your inheritance model so it knows shared from local, and shows a per-property diff before anything ships. Every change runs through your approval rules, is logged with who/when/which property, and can be rolled back in one click. You don't configure new safety for the AI, the structure, permissions, and approvals you already built are what contain it.
Agentic operation means you describe a change in plain language and the platform makes it across your properties, with human approval and a full audit trail. It runs on a free MCP server on every account, with 80+ tools and 400+ APIs. You bring your own AI model, so your model spend stays on your own provider contract.
Agentic commerce is online buying carried out by an AI agent on a shopper's behalf. The agent searches, compares and completes the purchase, often inside an assistant such as ChatGPT or Gemini, using open standards like the Agentic Commerce Protocol (ACP) or the Universal Commerce Protocol (UCP).
No. Agentic commerce sits on the customer's side and is about buying. Agentic operations sits on the operator's side and is about running the business. A company can use both for different purposes.
Core dna is built for agentic operations: running many properties from one platform by prompt, with approval, audit and rollback. It is not a consumer shopping-agent or a checkout protocol, though an operator can still sell through agentic commerce channels alongside it.
Agentic operations is when a business user prompts their platform in plain language to make operational changes, such as content, catalog and pricing updates, across multiple websites or stores at once. The agent works for the operator, not the shopper.
An AI feature helps one person finish a task faster inside one site, like drafting a headline or tagging an image.
Agentic operations go further: you describe an outcome once and the platform carries it out across every property you run, then routes it through your approval, audit, and rollback workflow.
Most platforms now add AI agents. The difference is whether those agents reach every property, touch commerce as well as content, and ship changes rather than stopping at a draft.
Most major enterprise CMS platforms now ship AI agents, and several expose them over MCP so external assistants can act on content.
The useful question in 2026 is no longer whether a platform has agents, but what they are allowed to do: how far across your properties one instruction reaches, whether they touch commerce or only content, and whether they ship through existing approvals.
The narrowest set of permissions that lets it do the specific job you hired it for. Agents should never inherit a human's permission set, and they should never share credentials with another agent or service. Permissions are granted at the tool level, scoped to the record types and actions the agent's job actually requires, and reviewed on the same cadence as the rest of your privileged-access program.
When it has demonstrated, in discovery mode, that its plans are the plans a human operator would approve, on a representative task set, over a window long enough to surface your edge cases. Write access is earned, not defaulted. And the first writes should be reversible, low-blast-radius actions inside a tight tool box - not high-stakes operations on customer-facing data.
Governed autonomy means an agent can act across your properties while a human approves changes, every action is logged, and any change can be rolled back. It gives a team speed without giving up control of live sites.
Short answer: AI shopping agents don't browse your site the way people do — they query structured data, ingest feeds, and increasingly call APIs to evaluate and transact. To be discoverable you have to make your catalog machine-readable (structured data), reachable (feeds and APIs pushed to the surfaces agents use), and trustworthy (accurate, fresh, well-reviewed). Get those three layers right and your products enter the agent's consideration set; skip any of them and you're simply invisible on the fastest-growing discovery channel in retail.
This is now a revenue question, not an IT-backlog one. Adobe's reporting showed AI-driven traffic to retail sites grew roughly sevenfold over the 2025 holiday season, and by early 2026 AI-referred shoppers were converting better than traditional traffic — a reversal from a year earlier, when the same cohort converted worse. The gap between merchants whose catalogs are agent-ready and those who aren't is widening fast.
How AI shopping agents actually read your catalog
A traditional search crawler tries to infer meaning from your page copy. An AI agent does the opposite: it wants explicit, structured facts and refuses to guess. When a shopper asks an assistant for "waterproof hiking boots under $200 that ship by Friday," the agent decomposes that into constraints — category, attribute, price, delivery window — and then evaluates candidate products against structured fields. Three implications follow:
- It queries attributes, not paragraphs. Marketing prose written for humans on the page contributes little. The agent reads product type, identifiers, price, availability, shipping, and returns as discrete fields.
- Incomplete data gets skipped, not tolerated. A human overlooks a missing spec; an agent treats a missing required field (a GTIN, a per-variant stock status) as grounds to exclude the product entirely.
- It decides in real time. Agents commit to a purchase in the moment, so a price or stock level that's even a few minutes stale produces a failed transaction — and a reliability penalty that hurts your future ranking.
The practical takeaway: your product data quality is now part of your distribution strategy.
The nine things to get right
1. Add Schema.org structured data (JSON-LD) to every product page
This is the foundation layer. Mark up Product and Offer with name, SKU, brand, GTIN, price, currency, availability, shipping, return policy, and aggregate rating. JSON-LD lets an agent extract the essentials without rendering your page. Schema-tagged product pages are also cited materially more often in AI-generated shopping results.
2. Complete your identifiers and attributes — especially GTINs
Missing GTINs (or manufacturer part numbers) are one of the most common reasons product lines get disqualified, because the agent can't reliably match the product. Populate unique product IDs, GTIN/UPC, brand, and category consistently. Aim for near-complete fill on your core fields; practitioners report that products with thin attribute coverage are routinely skipped, while high-fill catalogs get surfaced.
3. Get variants right
"Blue running shoes, sizes 7–13" is not one product to an agent — each variant needs its own accurate availability. Showing "in stock" when size 10 is sold out creates a failed checkout and damages your standing with the agent.
4. Write descriptions for intent, not for someone already on the page
Most product copy assumes the shopper has seen the image and filtered by category. An agent reads the description in isolation and needs it to answer the questions a shopper asks in conversation: who is this for, what's it used for, what's it compatible with, where would I use it. Add the same rigour to alt text ("men's linen shirt in pale blue, open-collar, outdoor setting" — not "IMG_4521.jpg") and to category descriptions, which set the interpretive frame for everything beneath them.
5. Keep feeds real-time accurate and internally consistent
Price and availability should reflect reality within minutes, not hours — the ChatGPT feed spec, for instance, accepts refreshes as often as every 15 minutes. Three failure modes to eliminate: price mismatch between your site and your feed (agents may reject or deprioritise you), stale stock, and missing geographic availability (recommending something that can't ship to the buyer is a failed experience).
6. Syndicate feeds to the surfaces agents actually use
Discoverability is per-channel. The main destinations in 2026:
- Google Merchant Center — feeds Google's AI Overviews / AI Mode and its emerging cross-surface cart.
- OpenAI / ChatGPT — sign up at
chatgpt.com/merchantsand provide a structured feed (CSV, TSV, XML, or JSON) pushed over HTTPS to an allow-listed endpoint. Merchants selling through Shopify or Etsy are already integrated with no extra setup. - Perplexity and Microsoft Copilot shopping surfaces.
- If you're on Shopify, Agentic Storefronts can syndicate one catalog to several of these at once.
7. Expose programmatic access — APIs and an MCP server
Discovery alone isn't enough once agents start transacting. To participate in the full lifecycle, your catalog, cart, checkout, inventory, shipping, returns/refunds, and order management should all be reachable via API — not locked behind browser-only sessions. The cleanest way to make your catalog agent-native is to expose a Model Context Protocol (MCP) server with tools like searchProducts, getProduct, getInventory, createCart, and getShippingOptions. Any compliant agent (Claude, OpenAI's agent, LangChain-style frameworks) can then call your source of truth directly instead of scraping rendered pages.
8. Build trust and authority signals
Agents weight reliability heavily. Invest in review volume and recency, publish clear return, privacy, and terms policy URLs (some feed specs require them), keep pricing competitive across channels, and expose a clear seller identity. Brand authority in the wider web corpus also influences whether an LLM recommends you at all.
9. Support agent payment authorisation
For agents that complete purchases, you'll eventually need to accept scoped, single-use payment credentials — e.g. Stripe's Shared Payment Token or the Delegated Payment Spec — while remaining the merchant of record on your existing processor. Google's agent-payment model adds pre-authorisation scoped by amount, merchant, time window, and product class. This is a 2026 awareness item and a 2026–27 build item for most teams.
The protocol landscape in 2026
The standards stack is still settling, but four names matter:
- MCP (Model Context Protocol) — Anthropic's open standard for letting agents discover and call tools on external systems. It's the most settled of the four (shipped late 2024, with support across major agents and frameworks) and is the natural way to make a catalog directly queryable.
- ACP (Agentic Commerce Protocol) — co-developed by OpenAI and Stripe, open-sourced under Apache 2.0, and the protocol behind ChatGPT's shopping. It bundles a Product Feed Spec, an Agentic Checkout Spec, and a Delegated Payment Spec.
- AP2 (Agent Payments Protocol) — Google's payments-and-authorisation layer, using verifiable credentials so a user can pre-authorise an agent within defined limits. Less mature; the spec and reference implementations exist but issuer/processor support is still building.
- UCP / "Universal Cart" — a newer, Google-backed effort to standardise catalog and checkout access across platforms and be protocol-agnostic (REST, MCP, A2A). Emerging — worth tracking rather than building against yet.
One important nuance: OpenAI has been shifting emphasis away from a standalone in-chat checkout toward product discovery plus merchant-owned checkout — shoppers evaluate products inside ChatGPT, then complete the purchase on your own site or app, with no fee on purchases that start in ChatGPT. Product results there are organic and unsponsored, ranked on relevance rather than paid placement. So the highest-leverage move for most merchants is still the feed and data work, not rushing to build a bespoke in-chat checkout.
How to know if it's working
Don't assume — verify:
- Ask ChatGPT, Perplexity, and Gemini to find products in your category with specific attributes, and note whether yours appear and how they're described.
- Check that the price, availability, and shipping the assistant shows are actually correct.
- Test edge cases: specific sizes, colours, configurations, and ship-to regions.
- Use Google Merchant Center's feed diagnostics to catch disapprovals and missing required fields.
- Watch for a new channel in your analytics — chat-originated / AI-referred orders — and track its conversion separately.
How Core dna makes this easier
Most of the pain above comes from one root cause: catalogs and inventory scattered across systems that were built to render pages for humans, not to answer machines. Core dna is API-first and composable by design, which puts you in the ready camp by default rather than retrofitting agent-readiness onto a page-driven store.
- A single structured source of truth. Your products, variants, categories, stock, orders, and fulfilment live in one canonical, structured model — the "clean schema, clean data" foundation every agent surface depends on. There's no reconciliation between a storefront, a PIM, and a plugin-generated feed drifting out of sync.
- Full-lifecycle REST/JSON APIs. Catalog, cart, checkout, inventory, shipping, orders, and fulfilment are all programmatically accessible — exactly the end-to-end reachability agents need to move from recommending your product to transacting against it.
- A native MCP server. Core dna already exposes your catalog, inventory, and order data as MCP tools an agent can call directly. This is the single hardest item on the checklist — making your source of truth agent-native — and it ships as part of the platform rather than being a project you scope from scratch.
- Compliant feeds from the canonical catalog. Because the product data is already structured and centralised, generating and refreshing the feeds the AI surfaces expect (OpenAI, Google Merchant Center, and others) draws from one accurate, real-time source — so price and stock stay consistent everywhere.
- Multi-property orchestration. If you run several brands, regions, or storefronts, you maintain one catalog and syndicate consistent data to every property. That directly solves the failure mode other platforms warn about — hundreds of fulfilment points and one stale price silently breaking the agent experience.
The strategic point: in an agentic world, the advantage sits with the operator who runs the whole digital estate from one back end, not the one who bolts a store onto a single channel. Shopify sells you a store; Core dna runs your estate — and an estate that's structured, API-first, and MCP-native is exactly what AI shopping agents are built to read and buy from.
(ACP checkout endpoints and agent-payment authorisation, e.g. AP2 / Delegated Payment, sit naturally on top of this composable architecture as integration points — you bring your own PSP and expose the endpoints against your existing order and checkout APIs.)
Where to start
A pragmatic order of operations:
- Fix the data. Audit fill rates on GTINs, variants, prices, availability, images, and policies. Treat gaps as disqualifications, because agents do.
- Add Schema.org JSON-LD to product and category pages.
- Rewrite descriptions and alt text for intent — who, what for, compatibility, context.
- Stand up real-time feeds to Google Merchant Center and OpenAI (
chatgpt.com/merchants), refreshed frequently, and connect any others you sell through. - Expose programmatic access — your APIs and an MCP server — then layer in agent-payment support as those protocols mature.
Then test with the assistants directly, and iterate on whatever they get wrong.
Sources & further reading
- OpenAI — Buy it in ChatGPT and Agentic Commerce overview:
https://openai.com/index/buy-it-in-chatgpt/ - OpenAI — Merchant onboarding:
https://chatgpt.com/merchants/ - OpenAI — Agentic Commerce key concepts (developer docs):
https://developers.openai.com/commerce/guides/key-concepts - Agentic Commerce Protocol — Product Feed Specification:
https://agentic-commerce-protocol.com/docs/commerce/specs/feed - Model Context Protocol:
https://modelcontextprotocol.io - Schema.org — Product / Offer vocabulary:
https://schema.org/Product - AI-commerce traffic and conversion trends as reported by Adobe (Adobe Analytics / Digital Insights, 2025 holiday season and early 2026).
More reading
Related posts