Most ecommerce stacks were built around a marketer operating them.
The store collects customer and order data, the ESP receives some of that, the marketer looks at what is happening, decides which customers to target, builds a segment, creates an email, schedules the campaign, and later checks the results.
An AI email marketing agent changes that operating model. If the agent is expected to identify opportunities, choose audiences, prepare campaigns, create emails, and learn from results, it needs access to much more than a prompt box.
The agent needs to understand what is happening in the store and be able to reach the customer and campaign data inside the ESP.
That makes agent readiness partly an AI problem, but largely a stack problem.
What does an ecommerce stack need to expose to an AI email marketing agent?
Start with the jobs you expect the agent to perform.
| The agent needs to… | Your stack needs to provide… |
|---|---|
| Understand the store | Products, prices, inventory, customers, orders and other relevant commerce data |
| Understand customer behavior | Purchase, browse, cart and email engagement events |
| Decide who should receive something | Customer-level data that can be queried and segmented |
| Build and execute marketing | Access to segments, campaigns, templates, flows and sending |
| Learn what happened | Campaign performance, conversions and revenue |
MCP, APIs and webhooks are ways of providing this access.
An agent has to be able to see enough of the business to make a useful decision, and then do something with that decision.
How much of that you get depends on which ecommerce platform you use.
Make your ecommerce platform readable by an agent
An email marketing agent needs reliable access to the commerce data behind the store, and it needs to receive important changes quickly enough to act on them.
- A restock opportunity is less useful if inventory data arrives a day later.
- A customer who just purchased should not remain in a campaign audience because the ESP has not received information about the new order yet.
Shopify
For Shopify stores, the main merchant-side interface is the GraphQL Admin API. It can expose products, variants, inventory, orders and customer information to applications with the appropriate access scopes. Shopify also supports Events and webhooks so external systems can receive changes instead of continually polling the store.
A Shopify brand preparing for agents should:
- Make sure the integration has access to the customer, order, product and inventory data it needs.
- Use Events or webhooks for important changes rather than relying only on periodic synchronization.
- Expose relevant merchant-specific data stored in tags, metafields or other custom fields.
- Capture storefront behavior such as product views, cart activity and checkout activity where it matters to the email program. Shopify’s Web Pixels API exposes standard events including product_viewed, product_added_to_cart, checkout_started and checkout_completed.
- Make sure subscription and consent information remains available before an email is sent.
Shopify also has newer agent interfaces for shopping experiences. For example, its current Shop MCP and storefront agent capabilities can search products, manage carts and support checkout. Those are useful for shopping agents, but they do not replace the merchant-side access an email marketing agent needs to understand and operate the business.
WooCommerce
WooCommerce exposes store data through its REST API. API keys can be given read, write or read/write permissions, and the API can be used to work with resources such as orders, products and customers.
For a WooCommerce store:
- Create appropriately permissioned REST API credentials for the system that will work with the store.
- Configure webhooks for the customer, order and product changes the agent needs. WooCommerce can also use custom actions as webhook triggers, including actions around cart activity.
- Check whether important information lives in WordPress plugins or custom fields that your normal commerce integration does not expose.
- Make sure browse and cart activity is captured separately where needed. Product and order APIs alone do not describe the complete pre-purchase journey.
WooCommerce also supports MCP through the WordPress MCP Adapter, which installs separately rather than shipping inside WooCommerce. Its current purpose-built abilities cover product and order operations and nothing else, and WooCommerce describes the implementation as a developer preview that may still change.
Enable it where it is useful, but do not assume MCP alone exposes everything an email marketing agent needs.
BigCommerce
BigCommerce has Store Management APIs for administrative work such as modifying products, orders and customer information. It also supports webhooks for events including orders, products, inventory changes, customers and cart activity.
For a BigCommerce store:
- Give the integration access to the relevant Store Management APIs.
- Subscribe to the store events that should reach the marketing system quickly.
- Expose the customer fields, catalogue attributes and other custom business data used in marketing.
- Verify how quickly the data reaches the system the agent will use.
BigCommerce has a Storefront MCP for shopper-facing activity such as product discovery, carts and checkout, which stores opt into through early access. It is also developing a separate Store Management MCP for administrative capabilities, but that management interface is currently an invite-only closed beta.
Adobe Commerce and Magento
Adobe Commerce provides REST and GraphQL APIs for integrations with external systems. Adobe I/O Events can also support event-driven applications so external systems do not have to depend entirely on polling.
A store using Adobe Commerce should:
- Create a properly scoped integration.
- Make the necessary catalogue, customer, order and other commerce data available through the appropriate APIs.
- Use event-driven integrations where important changes need to reach other systems quickly.
- Expose custom attributes that matter to the email program.
- Check that customer and commerce data remains consistent across the relevant stores and store views.
Adobe also has Commerce development MCP tools, but these are currently positioned around building and maintaining Commerce applications. They should not be confused with giving a marketing agent direct access to operate the merchant’s email program.
The same principles apply if you run a custom or headless commerce stack. The difference is that your team has to provide the APIs and events itself.
Verify what actually flows from your store into your email system
For a Shopify brand, Shopify already knows a great deal about customers, products and orders. The same is true of the other major commerce platforms.
So the useful question is not whether this information exists; it’s whether the email system receives enough of it, quickly enough, and at a level the agent can actually use.
- Check whether customer profiles and order history are synchronized.
- Check whether changes to products, collections, prices and inventory reach the email system.
- Check whether customer-level browse, cart and checkout events are available.
Then look at how the synchronization works:
- Are important events sent in near real time, or are they processed in batches?
- Can the ESP query individual events, or does it only have aggregate reporting?
- Is historical data available, or does tracking begin only after the integration is installed?
The final piece is whether commerce data can be combined with information that belongs to the email system, such as opens, clicks, campaigns sent, flow history and previous conversions. Having data inside the ecommerce platform and having that data unified and usable by an agent inside the email system are two very different things.
Make your ESP operable by an agent
Once the commerce side is ready, look at the ESP.
An agent that can only read data is useful for analysis. For an agent to operate email marketing, it needs write access as well.
At a minimum, the ESP should make these possible for an external system:
| The agent needs to be able to… | Read or write |
|---|---|
| Read customer profiles and events | Read |
| Inspect existing lists and segments | Read |
| Create or update segments | Write |
| Read campaigns and flows | Read |
| Create campaigns | Write |
| Create or update email content | Write |
| Configure audiences and timing | Write |
| Retrieve campaign results | Read |
| Create or change flows | Write (more advanced) |
If your ESP has MCP, check what it exposes
MCP gives AI systems a standard way to discover and use tools. That makes it useful, but the existence of an MCP server does not tell you how capable the connection is. What those connections open up depends entirely on what each one is allowed to do.
- One ESP might expose customer and campaign information.
- One might allow campaign creation.
- One might expose only a small subset of what the marketer can do through the UI.
So instead of asking whether your ESP has MCP, ask: What can an agent actually do through it?
- Can it query customer events?
- Can it create a segment?
- Can it build a campaign?
- Can it update an email?
- Can it inspect performance?
Check the underlying APIs too
The ESP should also have sufficiently complete read and write APIs for the work you expect the agent to perform. That can include profiles, events, segments, campaigns, templates, flows, catalogues, subscriptions and reporting.
Compare the API with the ESP’s user interface.
If a marketer can perform an important task in the UI but an external system cannot perform that task through an API or supported agent interface, that part of the process still requires a human operator.
Test your stack with real marketing jobs
You do not need to understand every API endpoint to determine whether your stack is ready.
Give the system real jobs.
Ask it to:
“Find customers who bought a particular product 60 to 90 days ago but have not reordered.”
Can it access the purchase data and create the audience?
“A product is back in stock, find customers with the strongest evidence of interest.”
Can it combine the inventory change with relevant customer behavior?
“Prepare a campaign for a new collection.”
Can it understand the products, build an appropriate audience and create the email inside the ESP?
“Which campaigns from the last 60 days generated repeat purchases, and what should we do next?”
Can the system connect campaign activity to what customers eventually bought?
These tests expose gaps much faster than a checklist of integrations.
Connectivity still does not give an agent enough context to run email marketing well
Suppose all of this works and you have made the stack operable by an agent. That does not necessarily build an email marketing agent.
Those connections do not automatically tell the system which products matter this week, how the brand normally communicates, what types of promotions it is willing to run, which customer opportunities deserve attention, how aggressive it should be with discounts, or what has worked for the brand before.
They also do not give the agent an ongoing understanding of the business.
That difference matters because the hardest part of email marketing is rarely clicking the button that creates a segment or sending HTML to an ESP. It is deciding what deserves to be sent in the first place.
The final layer is an ESP built for agents
Traditional ESPs were designed around a human operator. APIs and MCP can give an AI access to that same system, but the underlying model can remain unchanged. The AI is simply another operator waiting to be told what job to perform.
An ESP built for agents should work differently.
It should continuously understand the store and catalogue, maintain customer context, watch changes in customer and store activity, understand previous campaigns and their results, and identify opportunities without waiting for a marketer to specify every campaign.
From there it can recommend the audience, products, offer and timing, prepare the campaign, ask for approval where appropriate, execute the work, measure what happened and use those results when making the next recommendation.
That is the shift ecommerce teams should prepare for.
- The first step is making your existing stack accessible to agents.
- The bigger step is moving toward a stack designed for agents to operate.
Is your ecommerce stack agent-ready?
Use these questions as a quick test.
| Question | Ready? |
|---|---|
| Can an agent read your customers, orders, catalogue and inventory? | ☐ |
| Does it receive important store changes quickly? | ☐ |
| Can it access customer-level onsite behavior? | ☐ |
| Can it read and create ESP segments? | ☐ |
| Can it create campaigns and email content? | ☐ |
| Can it access previous campaign performance? | ☐ |
| Can it connect email activity back to purchases? | ☐ |
| Does it understand your brand and campaign history? | ☐ |
| Can it recommend what to do without you defining the campaign first? | ☐ |
| Are approvals and permissions defined for the actions it can take? | ☐ |
The first several questions tell you whether an AI agent can access and operate your current stack; the later questions tell you whether the system can begin doing the work of an email marketer.
That is the difference between connecting AI to an ESP and building an email stack for AI agents.
If you are weighing platforms rather than auditing the one you have, how to evaluate an AI email marketing platform and should you switch ESPs are the two to read next.
Nexie is an AI-native ESP for e-commerce brands. It reads your customer data across engagement, recency, category interest and lifetime value together, surfaces the audiences worth campaigning to, and builds those campaigns for your team to review and approve, inside the guardrails and marketing policies you set. See how it works →

