Enterprise software has always made complexity the price of power but agentic AI is about to break that tradeoff. Journey Optimizer is evolving from a system operators run to one they direct, with agents handling the execution while humans focus on strategy.
Charting the future
There's a paradox at the heart of enterprise software: the more capable the platform, the greater the burden on the people using it. Journey Optimizer is no exception. Built to give operators full, tactical control over complex, real-time customer experiences, it delivers exactly that precision - but at a cost. Giving operators full power means presenting them with a cockpit of buttons and switches, a surface area so broad that it extracts a high cognitive load just to operate effectively. A recent Harvard Business Review study found that 86% of CEOs cite rising complexity as a barrier to growth, driven in large part by fragmented systems and overwhelming operational demands. That's not a Journey Optimizer problem. That's an enterprise software problem. And it's one the industry has accepted as an unavoidable tradeoff - until now.
The more time I spend leading the agentic reimagination of this product, the more I believe that tradeoff is about to be eliminated. Gartner predicts that 40% of enterprise applications will be integrated with task-specific AI agents by the end of 2026, up from less than 5% today. That trajectory is precisely what's shaping the reimagination of Journey Optimizer.
Right now, Journey Optimizer is a powerful tactical operations suite. You define audience segments, configure real-time triggers, set up decision logic, A/B test messages, build content and templates, and monitor performance. It's sophisticated work - and it takes real expertise to do it well. But this is true of every enterprise marketing platform: no matter how well designed, the operational execution required to run these systems at scale means that a significant portion of a team's time is spent on the mechanics of the journey rather than the strategy behind it. Our users don't necessarily wake up thinking about wait nodes or suppression logic (nor should they). They wake up thinking about their business goals, their customers, and their growth. Tactical execution is simply a means to an end.
AI - and more specifically, agents - are poised to absorb that overhead entirely. Consider a future where an agent monitors your journeys in real-time, detects underperformance, hypothesizes the cause, and autonomously restructures the experience. Where you don't set up an A/B test, you set an objective, and the agent runs continuous experimentation to get you there. Where onboarding a new campaign doesn't require a team of specialists configuring a workflow, it requires a conversation. This isn't a distant scenario. It's the direction we're actively building toward.
The implications for the product - and for the operators who use it - are significant. If agents handle the tactical execution, the product's job fundamentally changes. Journey Optimizer stops being a system you operate and instead becomes a system you direct. There's also a deeper dimension here that often goes unexamined: enterprise software has historically been designed to mirror how people and processes are structured within large organizations - reflecting org charts, approval hierarchies, and team boundaries rather than the outcomes those organizations are actually trying to achieve. Agentic AI breaks that mold. When an agent can coordinate across functions, adapt to context, and execute autonomously, the product no longer needs to reflect organizational structure; it can reflect organizational intent. The interface shifts from configuration to conversation. The skill that matters stops being "can you build a journey?" and starts being "do you know what journey to build, and why?" That's a genuine strategic elevation - and it opens real value at every level of an organization. For business users, it means getting out of the weeds. For power users, it means spending time on problems that actually require human judgment. For organizations, it means scaling personalization in ways that weren't economically feasible before.
For those wondering what this looks like in practice, the near-term work is focused on three things: reducing the expertise required to build a journey from scratch, shortening the time it takes to diagnose what's going wrong, and giving teams the ability to simulate customer experiences at scale before going live. These aren't moonshots - they're the moments operators find most painful today, reimagined with agents doing the heavy lifting.
What few talk about, though, is that the shift to agentic AI in an enterprise product like Journey Optimizer isn't just a technical challenge - it's a trust challenge. Marketers and operators need to feel confident that an agent acting on their behalf is acting correctly. Bain's Technology Report 2025 puts it cleanly: enterprises need to ensure agents have the context they need in real time, the ability to observe and explain behavior, and the guardrails to execute safely - and most current architectures simply aren't built for that yet. This is where we're investing significant thinking in how we design the agentic layer of Journey Optimizer. Trust in an autonomous system isn't a single feature - it's a framework. It means granular roles and permissions so that agents operate within boundaries that reflect how each organization governs its marketing. It means collaboration and hand-off workflows so that humans remain in the loop at the moments that matter most. It means full audit logs so that every action an agent takes is traceable and explainable after the fact. And it means transparent, inspectable plans - the ability to see exactly what an agent is about to do before it acts, and to course correct if needed. Getting that framework right is where I spend a lot of my thinking, because the vision only works if people trust the system enough to let go.
The end state is still coming into focus, but the direction is clear. Journey Optimizer is evolving toward something that, until recently, seemed like a contradiction in terms: the full power and precision of enterprise software, with the simplicity that only agents can unlock. Enterprise complexity and agent-guided simplicity - not as a tradeoff, but as a combination. That's what we're building toward. And I think it's the most interesting problem in enterprise software right now.
What this means for you today
The shift described above isn't something that will arrive all at once; it's already underway, and the organizations that navigate it best will be those that start thinking about it now, rather than when the capabilities are already in place.
The most useful thing you can do today is audit where your team's time actually goes. How much of a typical week is spent on journey mechanics - configuration, troubleshooting, QA, content assembly - versus the strategic decisions that those mechanics are meant to serve? Agents will absorb the former first. Understanding your current baseline provides a clear lens for measuring the impact as these capabilities are implemented, and it highlights the areas where relief will be most significant.
Concurrently, it's worth beginning to draw a clearer line between the decisions that require genuine human judgment and the work that is purely executional. Audience strategy, brand guardrails, campaign objectives, governance boundaries - these are the things operators should be spending their time on. Articulating them explicitly, rather than leaving them implicit in how your workflows are structured, will make it significantly easier to configure and govern agents when the time comes.
The trust question is also worth thinking about before you need to answer it. The organizations that adopt agentic capabilities fastest will be those that already have internal clarity on governance - who can authorize what, what actions require human sign-off, and how accountability is maintained when an agent acts on your behalf. These aren't technical questions. They're organizational ones, and they take time to work through. Starting those conversations now, even informally, puts you ahead of the curve.
Finally, the product is moving in this direction in part because of the feedback we hear from operators about where the friction is highest today. If there are aspects of your Journey Optimizer workflows that feel more burdensome than they should - assembly, troubleshooting, testing, or otherwise - that input is genuinely useful. The Experience League community, your Adobe account team, User Advisory Boards, and direct product conversations are all channels where feedback shapes what gets prioritized.