The Agentic Evolution of Adobe Experience Manager

Adobe Experience Manager is entering a new phase. And this one changes how work actually gets done.

In a recent Adobe Developers Live session, Cedric Huesler and Martin Buergi walked through how AEM is evolving toward an agentic architecture. One where intelligent agents interact directly with content, workflows, and delivery systems using MCP and A2A APIs.

The implications are practical, not theoretical.

Experience Manager has traditionally been something developers operate through UIs, pipelines, and APIs. That still matters. What’s new is that AEM is now designed to be something agents can reason over, act upon, and coordinate across tools.

This post focuses on what that means in practice. We’ll look at the architectural foundations behind agentic AEM, how workflows like instructional authoring change day-to-day development, why Edge Delivery Services matter more than ever, and how you can start experimenting with the developer agent today.

Start here if you’re new to agentic AEM

Here’s the short version.

Adobe Experience Manager now includes intelligent agents that can carry out structured tasks on your behalf. These agents interact with content and workflows through MCP and A2A APIs, both inside the product UI and from external tools.

You describe intent.
The agent executes safely.
You review and stay in control.

Everything else in this article explains how that works under the hood and where it fits into real developer workflows

From cloud-native CMS to agentic platform

AEM has been cloud-native for several years. This evolution goes further.

The platform is expanding beyond UI-driven and API-driven interactions toward a model where agents can reason about content and execute workflows directly. That shift touches authoring, delivery, and orchestration across channels.

The motivation shows up quickly once you look at real teams.

Even highly optimized AEM teams still coordinate pipelines, deployments, and approvals for relatively small changes. The architecture scales well, but the execution overhead adds friction.

At the same time, discovery patterns have shifted. Content is increasingly consumed by AI-driven systems that prioritize speed, structure, and clarity. These systems fetch raw HTML, ignore JavaScript, and enforce strict performance thresholds.

Agentic AEM responds to both realities.
Execution moves closer to intent.
Delivery aligns with how modern systems actually consume content.

The architectural foundations of agentic AEM

Agentic AEM builds on existing Experience Manager architecture rather than replacing it.

Repository foundations

AEM already spans multiple generations of content storage:

Agentic AEM introduces an abstraction layer above these systems. Agents do not need to know where content lives or how it is stored. They operate through a consistent access model regardless of repository type.

MCP and A2A as the access layer

At the center of this evolution is a new service layer that exposes Experience Manager capabilities through Model Context Protocol and A2A APIs.

This layer enables controlled access to operations such as:

Instead of building brittle integrations, tools can discover what AEM supports and invoke those actions safely. Authentication uses OAuth, API keys, or tokens depending on context, and destructive actions require confirmation and safeguards.

The agent layer

Above the access layer sits a growing set of AEM agents.

These agents understand tasks rather than endpoints. They can interpret instructions, coordinate multiple steps, retry failures, and apply changes across repositories without developers managing those details directly.

This is the core architectural change. Work shifts from step-by-step execution toward intent-driven direction.

Instructional authoring as a new workflow pattern

One of the most meaningful changes introduced with agentic AEM is instructional authoring.

Historically, Experience Manager supported two primary authoring models:

Agentic AEM introduces a third.

Instructions become the input.

That instruction might be:

Agents interpret those instructions and apply them while preserving AEM’s separation of concerns. Content, design, and code remain distinct even if the experience feels unified.

For developers, this changes how work flows. Instead of executing every operation manually, you describe intent and let agents handle the mechanical steps in a controlled, repeatable way.

Using the developer agent inside Experience Manager

Inside Adobe Experience Manager, agents are surfaced through the in-product AI assistant.

The developer agent can:

Developers remain responsible for outcomes. The agent handles execution.

By reducing repetitive steps, teams spend more time validating architecture, reviewing decisions, and shipping confidently.

Using AEM agents outside the UI

The same agents can be accessed outside the Experience Manager UI through MCP endpoints.

From external tools, an agent can:

Because MCP abstracts repository differences, these workflows behave consistently across AEM as a Cloud Service, older models, and adjacent systems such as Adobe Commerce.

This opens up practical integrations:

Safe experimentation with AEM Playground

Adobe introduced AEM Playground to make agentic workflows approachable.

Playground environments:

Agents in Playground cannot access production content. This removes operational risk and gives developers space to experiment, test prompts, and understand agent behavior safely.

For hands-on learning, Playground is the fastest entry point.

Why Edge Delivery Services matter in an agentic model

Agentic AEM pairs naturally with Edge Delivery Services.

Edge Delivery renders content as lightweight HTML with minimal processing. That matters because AI-driven systems:

If content responds slowly or depends on client-side rendering, it may never be read.

Edge Delivery allows the same content blocks to be reused across traditional pages, embedded applications, and agent-driven interfaces with minimal extra work.

This directly affects visibility and citation in AI-driven discovery.

Performance, citations, and discoverability

When AI systems generate grounded responses, they tend to:

Pages that respond slowly or hide critical information are often excluded.

The content cited most often is usually documentation, specifications, or reference material that answers a question clearly.

Agentic AEM helps developers respond by:

Key takeaways

FAQ

What is agentic AEM?
Agentic AEM describes Experience Manager evolving into a platform where intelligent agents can reason over content, execute workflows, and integrate across tools using MCP and A2A APIs.

Does this replace traditional AEM development?
No. Manual execution decreases, while architecture, content modeling, and governance become more important.

Are agents only available inside Experience Manager?
No. Agents are available both inside the AEM UI and externally through MCP endpoints.

Why are Edge Delivery Services important for agentic AEM?
AI-driven systems consume fast, lightweight HTML and ignore JavaScript. Edge Delivery aligns with how content is fetched, ranked, and cited.

Building with AEM?

Stay up to date on new features, developer tooling, and community events.

→ Subscribe to the AEM Developer Newsletter