Does Celigo Remember Between Runs? The Watermark Holds. The Reasoning Does Not.
Does Celigo Remember Between Runs? The Watermark Holds. The Reasoning Does Not. Ask whether Celigo remembers between runs and the honest answer splits in two. Celigo remembers where a flow stopped, in precise detail, because moving records between systems without losing or duplicating them is its entire job. It does not remember what an automation or an AI agent was trying to accomplish with those records, why it handled an exception the way it did, or what it already learned yesterday. Those a
Does Celigo Remember Between Runs? The Watermark Holds. The Reasoning Does Not.
Ask whether Celigo remembers between runs and the honest answer splits in two. Celigo remembers where a flow stopped, in precise detail, because moving records between systems without losing or duplicating them is its entire job. It does not remember what an automation or an AI agent was trying to accomplish with those records, why it handled an exception the way it did, or what it already learned yesterday. Those are different kinds of memory, and confusing them is how scheduled integration flows end up re-asking the same questions, re-trying the same fixes, and re-deciding the same edge cases on every single run.
What Celigo actually keeps
The clearest piece of Celigo memory is the delta watermark. When an export is set to Delta, integrator.io exports only the data that changed since the last time the flow ran. It does this with a value called lastExportDateTime, calculated automatically from the last time the flow ran and successfully exported data. A query can ask for records after that moment, so a NetSuite-to-CRM sync touches the orders that changed overnight instead of re-reading the entire account. A run that fails while exporting does not move the watermark, even if it had already exported some records. The next run starts from the same point and covers the same period again, so nothing gets skipped. That is real, careful memory, built for exactly one purpose: knowing where the data left off.
Celigo also keeps a detailed record that runs happened. Run history shows the last 1,000 runs for a flow, or follows the account data retention limit, whichever is shorter. Retention for flow history and error retry data is 30 days by default and up to 180 days depending on the plan. Each history entry holds the flow, its status, duration, start and completion times, and its success, ignored, and error counts. Errors keep their retry data, so a failed record can be edited and retried instead of rebuilt by hand. Audit logs go further, recording who changed a flow and what changed, and those can be kept for one to three years depending on the tier.
Notice the shape of all of this. Celigo remembers timestamps, counts, statuses, and configuration changes. History records are static: resolve a hundred errors from a past run and that run's history still shows a hundred errors produced, because the history describes the run as it happened, not the operation as it stands now. The platform's memory is an operations log. It answers what ran, when it ran, and how it ended. It was never designed to answer what the work meant.
Where the watermark stops
The watermark is exact about data movement and silent about everything around the movement. Consider a scheduled order sync with an AI agent step that reviews exceptions: orders that fail address validation, customers whose records do not match across systems, items that need a human decision. Celigo tells the next run which records changed since the last successful export. It does not tell it which exception yesterday's run already investigated, what a support conversation established about that customer, which mismatch a person already ruled harmless, or why a particular order was routed to a warehouse instead of a store. The run reads the changed records perfectly and still re-investigates the same exception from zero, because the reasoning that resolved it never became part of any record the run can read.
The gap widens when several tools share the work. A Celigo flow, an agent in n8n watching the same accounts, and a reporting job in another tool can all touch the same order and still hold three different understandings of it. Each system keeps its own log, or keeps none. The watermark is shared with no one outside the flow. The reasoning is shared with no one at all, and every run that starts cold has to reconstruct it from raw records, invent it, or skip it and act on the data alone.
Celigo's own AI steps underline the distinction. A flow can call a tool or an AI agent on each record as it passes through. That gives the agent governed work inside the flow. Work inside a flow is not memory across flows: the agent can process today's record in full and still know nothing about what it concluded last Tuesday, unless something outside Celigo kept that conclusion for it.
What a shared memory layer adds
The fix is not to replace the watermark. The watermark does its job well. The fix is to give the runs themselves a memory that sits alongside Celigo, in a place every tool in the workflow can reach.
That is the role of Vilix AI. Vilix AI is a cloud-hosted memory layer for AI agents and automations, reached over MCP, so there is no database to provision, no vector store to maintain, and no infrastructure to run. A Celigo flow's agent step, an n8n workflow, and a chat assistant can all connect to the same Vilix AI memory and read the same shared state, instead of each keeping a private log the others cannot see.
What gets stored there is the kind of memory Celigo does not keep: the full conversation history and working context, not just extracted facts. When an exception gets investigated, the investigation itself is saved. When a run decides how to handle a mismatched customer, the decision and its reasons are saved. The next run, in any connected tool, retrieves what is relevant to the records in front of it and starts from what is already known instead of from a watermark and a blank page.
Getting started takes minutes. Create an account, connect Vilix AI as an MCP server in the tools that run the automations, and let each run save its conclusions as it works. The free plan is free forever, and the Pro plan comes with a 7-day trial with no card required, so the setup can be tested against a real scheduled flow before any commitment. Memory stays under the operator's control: it can be exported or deleted at any time.
The practical test
A useful test for any automation stack is simple. Pick the last exception a flow handled more than once and ask where the knowledge from the first handling lives. If the answer is a run-history entry with a count and a timestamp, the stack remembers that work happened. It does not remember the work. Celigo will keep holding the watermark, exactly and reliably, for as long as the flows run. Give the runs a memory of their own in Vilix AI, and the next run stops re-asking questions the last run already answered.