Journey Simulation Agent — Cover Your Whole Journey in a Few Clicks with AI-Built Test Users, No Hand-Crafted Data

Introduction

A little while ago we introduced Simulation Mode — a way to test run a draft journey with lightweight, AJO-native Simulated Users before you ever publish. It was a big step: instead of pulling in AEP test profiles to try out a journey, you could spin up purpose-built test profiles right inside AJO.

But Simulation Mode still left one job on your plate: you had to figure out which test users the journey needed, and you had to build each one by hand.

The Journey Simulation Agent takes that job off your plate. It reads your journey, works out the minimal set of paths needed to exercise every branch, and uses AI to generate a realistic test user for each one, complete with the profile attribute values that path needs. Then it triggers them into the journey and hands you a single verdict: is this journey ready to publish, or not?

This post walks through that end-to-end, using an example journey.

The Problem: Simulation still runs on hand-crafted data

Simulation Mode solved where your test data comes from. It didn't solve how much work it is to produce that test data.

[UI snapshot: Example journey in Draft state]

Picture an example journey. A start, a condition that splits on homeAddress.country, a further condition in one of the branches that splits on homeAddress.city leading to a total of three branches in the journey. An Email message action with an End on each of the three branches.

To simulate this journey today you have to:

1. Read the journey like a compiler. Trace every branch and decision point and enumerate the distinct paths a profile can take. Miss one and you ship an untested branch.
2. Reverse-engineer the data each path demands. The test user has to satisfy all the conditions along its path simultaneously. Path 1 needs country = "Romania". Path 2 needs country = "India" and city = "Delhi". If the downstream Email content also contains person.firstName, person.fullName, the test user has to contain those profile attributes as well.
3. Hand-build a Simulated User per path. For each test user you type in each profile attribute the journey touches.
4. Trigger them, then read the logs yourself to work out which users actually made it end-to-end and which stalled.

This process is time-consuming and easy to get wrong — and it scales badly. Add one more branch and the number of paths (and hand-built users) grows with it. For a practitioner who just wants to confirm a journey works before publishing, it's a lot of manual bookkeeping standing between "draft" and "confident."

The Solution: Journey Simulation Agent

The Journey Simulation Agent automates the entire loop above. Under the hood it does four things you'd otherwise do by hand:

1. It finds the minimal set of paths that cover the whole journey. The agent walks the journey graph from the start node and enumerates every route to an end node. It then applies a set-cover step so you get the smallest set of test users that still exercises every edge in the journey — no redundant profiles, no missed branches.

2. It generates a realistic test user for each path — with AI. For every path, the agent hands the path's conditions and profile schema to an LLM, which produces a complete, internally consistent profile that satisfies all the conditions along that path. Names look like names ("Maria", not "test_user_2"), cities are real cities, country codes are ISO codes, dates are well-formed, and the full name actually contains the first name. Attributes the journey never references simply aren't invented.

3. It wires up real delivery details so you can verify content first-hand. The agent reads the email address / phone number from your own profile and uses them as execution fields, so proofs of the Email and SMS actions in the journey actually land in your inbox and on your phone. You're not just checking that a branch was reached — you can read the rendered message. (You can edit these values before the run if you'd rather send elsewhere.)

4. It runs the users and grades the result. After triggering the generated users, the agent inspects each one's node-by-node traversal logs, confirms it took its intended path from start to end, and rolls everything up into a Simulation Analysis summary: how many paths the journey has, how many were covered, how many failed, and — the bottom line — whether the journey is ready for publication.

Net effect: the analysis you used to do by eye, the data you used to type by hand, and the log-reading you used to do all collapse into a handful of clicks.

How to use the Journey Simulation Agent: a step-by-step guide

Here's the whole loop at a glance:

Step 1 — Start Simulation mode for the draft journey.
Step 2 — Generate test users with AI (the agent finds the minimal paths and builds a user for each).
Step 3 — Trigger the test users into the journey.
Step 4 — Read the Simulation Analysis to see whether the journey is publish-ready.

The agent offers two ways to run this: Quick Simulation, which does Steps 2 and 3 in a single click, and Manual Simulation, which separates them so you can review the generated users and choose who to send. We'll cover Step 1 first, then walk through both modes.

Step 1: Start Simulation mode

Open the Journey authoring page for a journey in Draft status. In the top-right menu, click “Simulate”. (This button is enabled only when the journey has no errors.)

In the dialog, choose “Simulation” and click “Confirm”. The journey moves into the Simulation state.

[UI snapshot: the **Simulate** button in the top-right menu and the **Simulation** confirmation dialog]

Once you're in Simulation, you'll see the two modes the agent offers — “Quick Simulation” and “Manual Simulation”.

[UI snapshot: the Simulation panel showing both **Quick Simulation** and **Manual Simulation** options]

The Fast Path: Quick Simulation

Quick Simulation is the fastest way to check whether your journey works. It combines test-user generation (Step 2) and triggering (Step 3) into one action.

Steps 2 & 3 — Click “Quick Simulation”. The agent then, in sequence:

1. Gathers your execution fields — the email address and phone number from your profile — so proofs of any Email/SMS actions in the journey reach you directly. You can edit these before it proceeds.
2. Generates the simulated users — one per valid path, with AI-generated attribute values that satisfy that path's conditions.
3. Triggers them into the journey and
4. Waits to confirm they've successfully entered

> [UI snapshot: the sequence of steps running inside Quick Simulation]

Step 4 — Click “View Results”. The Simulation Analysis summarises the run. In our example journey, all three generated test users covered their respective paths end-to-end, so the summary reports full coverage and marks the journey ready for publication.

> [UI snapshot: the Journey Simulation summary showing full path coverage and a publish-ready verdict]

The Controlled Path: Manual Simulation

Manual Simulation gives you the same automation with an inspection point in the middle — useful when you want to inspect the generated users, or send only some of them.

Step 2 — Click “Manual Simulation”, then “Generate with AI”. A dialog shows the Execution Fields (email / phone) pulled from your profile for sending proofs; edit them if needed, then click **Generate**.

[UI snapshot: the **Generate with AI** action and the Execution Fields dialog with the **Generate** button]

The agent generates the simulated users — again, one per valid path — and lays them out in a table so you can review each user.

> _[UI snapshot: the table of AI-generated test users, one row per path]_

Step 3 — Trigger the users. Click “Send all” to push every user into the journey at once, or trigger (or skip) each user individually from its row.

> _[UI snapshot: the generated-users table with the **Send all** button]_

Step 4 — Read the results. Once the users have entered the journey successfully, switch to the “Results” tab for the Simulation Analysis. It behaves exactly the same as in Quick Simulation — same coverage breakdown, same publish-readiness verdict.

> _[UI snapshot: the Journey Simulation summary on the **Results** tab]_

Summary

Simulation Mode gave you a convenient place to test a draft journey. The Journey Simulation Agent makes that test effortless:

• No path analysis by hand — the agent finds the minimal set of paths that covers every branch.
• No hand-built test users — AI generates a realistic, condition-satisfying profile for each path.
• First-hand verification — proofs of Email/SMS actions land on your own email and phone.
• A clear verdict — the Simulation Analysis tells you exactly which paths passed, which failed, and whether the journey is ready to publish.

What used to be a careful, manual pre-publish ritual becomes a handful of clicks — Quick Simulation when you quickly want the answer, Manual Simulation when you want to inspect the users first. Either way, you get to confident and publish-ready a lot faster.

Reference Links

We deliberately kept this walkthrough to a journey with no event nodes. If your journey waits on events — an app open, a purchase, a custom event — simulation has a few extra moving parts, and the agent handles those too. That's the subject of our next post — Simulating journeys with event nodes. You can also consult Journey Simulation Agent — Experience League documentation.