Does Automatisch Remember Between Runs? Executions, Step Outputs, and What Starts Blank

Short answer: not in the way most people mean by memory. Automatisch remembers a flow while it is running. Step outputs pass from step to step inside a single execution, and the finished execution stays on record to inspect. The next run starts with its trigger data and nothing carried over from the run before.

That is not a flaw in how the tool was built. Automatisch is an open-source, self-hosted workflow automation tool in the Zapier family: you build flows from a trigger and a chain of actions, and let them move data between services. Moving data inside a run is the job it was designed for. Remembering across runs is a different job, and no part of the flow builder quietly does it for you.

What actually persists in Automatisch

Three things survive a run, and it helps to name them precisely, because each one looks like memory from a distance.

The flow definition persists. Triggers, actions, connections, and settings are saved, so every run follows the same recipe. The recipe is remembered. The cooking is not.

Step outputs persist inside the execution. When a step finishes, later steps in that same run can use what it produced: the fields from a new row, the body of an email, the result of an HTTP request. This is how a flow threads data from its trigger to its final action. Once the execution ends, those values belong to that finished run.

Executions persist as a record. Past runs can be opened in the Executions view and checked: what each step received and returned, and where something failed. That record is useful for debugging, but it is written for your eyes. The next run does not open it or reason over it.

Put together: the platform remembers how your automation is built and keeps a log of what it did. It does not keep a working memory your next run can consult before acting.

Where that boundary shows up

For simple, self-contained flows, the boundary never matters. A flow that copies new form submissions into a spreadsheet needs nothing from yesterday. Each run is complete on its own, and forgetting is harmless.

The boundary starts to cost you as soon as a run's correctness depends on a previous run:

• Duplicate handling. A polling flow that checks an inbox, a feed, or an API on a schedule needs to know which items it already processed. Without a record it reads at startup, the same item can be acted on twice, or the flow leans entirely on the source app to mark items as seen.
• Follow-up logic. A flow that sends a first message on Monday and a nudge on Thursday has to know the first message went out, who replied, and who should be left alone. That history lives nowhere inside the next run by default.
• AI steps with judgment. Add a language model step that classifies, drafts, or decides, and the gap widens. The model sees only what this run's steps hand it. What it decided last week and what was already promised are absent unless your flow rebuilds that context and passes it in, every run.
• Several flows, one job. Real setups split work across flows: one collects, one enriches, one sends. Each holds its own step outputs for its own run. Nothing joins their pictures together, so the sending flow can act on a narrower version of events than the collecting flow saw.

Notice the pattern: every case is fixed not by a bigger variable inside one run, but by a record outside the run that the next run is required to read.

The usual workarounds, and what they cost

Operators who hit this boundary usually reach for one of three workarounds.

A spreadsheet or database as the ledger. The flow writes outcomes to a sheet, a table, or a file, and reads it back at the start of the next run. This works, and for one flow it can work well. The cost is maintenance: you design the schema, handle the lookups, keep the read-before-acting step from being skipped, and repeat the whole arrangement for the next flow that needs memory too.

Asking the source app to remember. Let the CRM hold the status and the inbox hold the read markers. This works until a decision spans several apps, at which point no single source holds the full story and the flow still reconstructs it run by run.

Rebuilding context in the prompt. For AI steps, the common fix is a longer brief pasted into every run: the rules, the history, the exceptions. Briefs drift, get edited in one flow and not another, and still only contain what someone remembered to write down, not what actually happened.

Each workaround stores data somewhere. None of them gives your flows and your AI tools one shared memory they all read and write as part of the work itself.

What changes with a shared memory layer

The structural fix is to put memory underneath the automation instead of inside any single flow. The flow still does what Automatisch does well, triggering, moving data, calling apps. Underneath it, a memory layer holds what happened: what was processed, what was decided, what is still pending, and what was actually said.

Vilix AI is built to be that layer. It is cloud-hosted, so there is zero infrastructure to install or maintain next to a self-hosted Automatisch setup. It is reached over MCP, so the same memory follows the work everywhere: the same record is available to your flows, to other automation platforms, and to the AI assistants you use during the day. It stores full conversation history, not just extracted facts, so a later run can revisit what was actually said and decided instead of working from a shortened note. The free plan is free forever, the 7-day Pro trial needs no credit card, and your data stays yours: export everything or delete it at any time.

That shape changes the daily experience in specific ways. A polling flow checks memory before acting, so handled items stay handled. A follow-up flow reads the real conversation before drafting, so the nudge sounds like a continuation, not a restart. A second flow, or a different tool entirely, works from the same record instead of a fragment. And a chat tool used to plan the automation works from the same history your flows wrote, instead of a summary retyped for it.

The bottom line

Does Automatisch remember between runs? It remembers your flow definitions, passes step outputs within a run, and keeps executions you can inspect afterward. It does not carry a working memory from one run to the next, share one across flows, or hand it to the AI tools around the automation.

If your flows are self-contained, that is enough. The moment a run needs to know what a previous run did or promised, the answer is a memory that lives outside the run, read before acting and written when the work is done, one memory for every flow and tool.