Does Iterable Remember Between Runs?

No. An Iterable journey holds no memory of its own between runs. When a user enters a journey, the journey reads that user exactly as the profile stands at that moment: the profile fields currently stored, the events currently on the record, and the lists the user currently belongs to. Anything an earlier run worked out survives only if that run wrote it back first, as a profile field update, an event, or a list change a later step can check.

That distinction is easy to miss because Iterable feels continuous. Profiles, events, and journeys are all still there tomorrow, and a user halfway through a journey resumes at the right tile. The continuity lives in records and definitions, not in a memory one run hands to the next.

What does an Iterable user profile actually hold?

A user profile is a set of fields. Iterable manages a group of system fields automatically, covering identity, subscription state, and activity, and a project can add custom fields for anything else: a plan name, a loyalty tier, a preferred language, a product preference. Custom fields support text, numbers, booleans, dates, arrays, and nested objects, so a profile can hold structured detail, not just flat labels.

Two properties of those fields decide what memory means here. First, a profile shows the latest value. When a field is updated, the new value replaces the old one, so the profile answers what is believed now, not what was believed last month or why it changed. Second, fields are durable schema. A field cannot be deleted once created, and its data type cannot be changed, which makes the profile a careful, permanent record of current state. It is not a notebook. It records no reasoning, no alternatives considered, and no note about which run set a value or what it had checked first.

Events remember that something happened

Events add the second shape of memory. System events record sends, opens, clicks, purchases, and subscription changes. Custom events record product actions a project chooses to track, sent through the API, an SDK, or an ingest sync, each carrying data fields that describe that one occurrence: an item name, an amount, a lesson completed, a cart total.

Saved custom events are stored on the profile, can trigger journeys and build segments, and are kept indefinitely by default, with an optional retention period that deletes them after a set time. Event status matters, though. A discarded event still appears in menus and its fields can personalize a message inside the journey it triggered, but it is not stored on the profile and cannot be used anywhere else. A deactivated event is not stored at all. So an event only becomes lasting memory when it is saved, and what it preserves is the fact that something happened, with the fields attached to that occurrence, not a conclusion drawn from it later.

What does the journey itself keep?

A journey built in Studio keeps its definition: its Start tile and entry source, its message, delay, filter, and split tiles, its exit rules, and its version history. Entry can come from an event, a schedule that adds list members at set times, an API call, or another journey, with entry rules and limits controlling who gets in and how often. Exit rules run as always-on checks that remove a user at any stage when a condition matches. The journey also keeps a position for each user inside it, which is why a user in a multi-day onboarding path continues from the right tile instead of restarting.

What a journey does not keep is a run journal. A filter or split tile reads profile fields and event data at the moment it runs. A User Update tile can write a value back to the profile, and that write is the one bridge from a journey's work to a later run's starting point. Catalog collections work the same way: a message looks up current catalog data at send time, so the content is fresh, but nothing about the lookup is remembered afterward. Live Data is held for the steps in a journey path that need it, and written to the profile only when a tile is set up to do so. Reading current state at the right moment is the design. Carrying a narrative forward is not part of it.

Where scheduled AI agents hit the same wall

Add a scheduled AI agent beside an Iterable account and the gap widens. The agent runs on a schedule, reviews users, checks events, drafts a follow-up, or decides which segment needs attention. Inside Iterable, its work survives only where it wrote a profile field, sent an event, or changed a list. Outside Iterable, in the chat or tool where the agent actually reasoned, the full context of that run, what it checked, what it ruled out, and why it chose one action over another, has no home on the profile at all.

The next run, whether it is the same agent tomorrow or a different tool next week, meets current values and a stream of events. It does not meet the reasoning. It re-reads the same users, re-checks the same events, and re-derives the same conclusions, because the one place that held the full story was the previous run itself, and that run ended.

Give the runs one shared memory

Vilix AI is built for exactly that missing layer. It is cloud-hosted with zero infrastructure to run, so there is no database to provision and no server to maintain before an agent can remember. Every connected tool reads and writes the same memory over MCP, so an agent working beside Iterable, a coding assistant, and a chat tool all share one state instead of separate run histories.

Vilix AI stores full conversation history, not just extracted facts. A later run can revisit what was actually discussed, checked, and decided, in order, rather than guessing from a profile field that only holds a latest value. That is the difference between a profile that says a user is on a plan and a memory that says why the plan was changed, what was already tried, and what should happen next.

The starting point stays simple: Get Started for Free. Free forever, no credit card. There is a free plan forever, and a 7-day Pro trial with no credit card required. Data stays portable throughout: export everything or delete it anytime. Connect a first agent, let it save its runs, and watch the next run start informed instead of blank, before any payment decision is due.

The short answer

Does Iterable remember between runs? The profile remembers, in current values. The event stream remembers that things happened, for as long as retention keeps them. The journey remembers its definition and each user's position inside it. The run itself remembers nothing. Anything that matters for tomorrow has to be written back today, as a field, an event, or a list change, or saved in a memory layer outside the journey. Give agents that shared memory, and each run starts where the last one finished.