Does Boomi Remember Between Runs? Chat Sessions Are Stored, Agent Steps Keep Nothing

Short answer: it depends entirely on how the agent runs. A Boomi agent you chat with keeps its conversation inside that session. A Boomi agent that runs as a step inside a scheduled integration keeps nothing at all. Boomi's own documentation states the second part plainly: for Agent Step use, prompts and responses are processed to continue the integration flow, and no record is retained.

That split surprises teams, because the word memory gets used for both cases. Untangling them is the difference between an automation that quietly repeats finished work and one that picks up where the last run stopped.

The two Boomi agent modes remember very differently

Chat sessions are stored. In Agentstudio's chat interface, the agent session, meaning the conversation history and prompts, is stored indefinitely unless the user deletes it. A person can return to that conversation and continue it. Boomi also isolates each session: chat history is stored within the specific agent session, so one session does not read another.

Agent Steps store nothing. When the same kind of agent runs inside an automated integration, Boomi's retention table gives the opposite answer. The agent session for an Agent Step is not stored. Prompts and responses are processed in memory to continue the flow and are not persisted. When the execution ends, the reasoning, the intermediate answers, and the conclusions end with it.

Tool outputs are not stored either. Boomi's documentation adds a line that matters for scheduled work: outputs generated by tools during a session are processed for execution but are not persisted. The lookup the agent ran, the record it checked, and the result it acted on do not become a record the next run can consult.

The agent's definition is what persists. Goals, instructions, and tool definitions are stored indefinitely. Every run follows the same instructions with the same tools. The recipe survives. What the agent learned by cooking does not.

Boomi's roadmap language points the same way. Its recently shipped memory feature is described as session-scoped memory: agents remember previous tool responses across a session. Across a session is the boundary. A scheduled execution next Tuesday is a new session, and it starts from the instructions alone.

What a scheduled Boomi agent therefore cannot know

Picture a nightly integration that checks open orders, flags the ones stuck in the same state too long, and posts a summary. On Monday the agent step works through the list and flags order A as stuck, noting it was already escalated once. On Tuesday the execution runs again. Because the Agent Step retained nothing, Tuesday's run cannot know:

• Which orders Monday's run already flagged or escalated
• What Monday's run concluded about an order that still looks stuck
• Which summaries were already sent, and to whom
• What a human replied or approved after Monday's run finished

Tuesday's run re-derives everything from the live data in front of it. Where the source systems hold the full story, that can be enough. Where part of the story lived only in the previous run's reasoning, a reply, a judgment call, a decision to wait one more day, the new run has no way to recover it. It flags order A like a first offense, sends a second escalation, and the team learns about the gap from the people who received both.

The workarounds are familiar. Teams write run state into a database table, a document cache, or a tracking spreadsheet, then build steps that read it back and clean it up. That works, and it quietly becomes a second system to design, secure, and maintain, one that stores state for the automation platform rather than memory an agent can reason over. It also stays inside Boomi: an agent running in another tool, or a person switching between an integration agent and a chat assistant, cannot read it.

The layer built for exactly this gap

Vilix AI is a hosted memory layer that sits outside any single automation platform. Your agents connect to it over MCP, read what previous runs learned before acting, and write back what this run decided, so the next run, in Boomi or anywhere else, starts briefed instead of blank.

Four properties make it fit scheduled work specifically:

It is cloud-hosted with zero infrastructure to run. There is no server, database, or cache for you to provision and maintain. You connect an agent and it has a memory.

The same memory follows the agent everywhere. Because it is reached over MCP, the memory is shared across tools and devices. A run inside Boomi, a workflow in another automation platform, and a chat in a coding assistant can all read and write the same memory instead of each keeping a private fragment.

It stores full conversation history, not just extracted facts. The actual exchanges, decisions, and reasoning are kept, so a later run can revisit what was said and why, not only a short summary line.

Starting costs nothing and leaving is clean. The free plan is free forever, and the Pro trial runs 7 days with no credit card required. Your data stays yours: export everything or delete it anytime.

A practical way to combine them

Keep Boomi doing what it is built for: governed integrations, connectors, and agent orchestration inside the enterprise platform. Add one habit around the agent steps that carry judgment from run to run. Before the step acts, it checks Vilix AI for what earlier runs recorded about the items in front of it. After it acts, it saves what it flagged, sent, decided, or is waiting on. The schedule still triggers the work. The memory makes the work continuous.

So, does Boomi remember between runs? In chat, yes, inside that one session. In the scheduled integrations where automation earns its keep, no, and Boomi documents that directly. Once a run's correctness depends on a previous run's reasoning, that memory has to live somewhere built to hold it. Give the agent one memory it can carry into every run, and Monday's conclusions are still there on Tuesday.