Does Metaflow Remember Between Runs? Artifacts Are Saved, the Next Run Still Starts Fresh.

Metaflow is unusually good at saving what a run produced. That is not the same as remembering what happened last time in a way the next run can use on its own. The difference matters as soon as a scheduled flow contains an AI step that has to decide, draft, or follow up based on yesterday, last week, or the last conversation.

What Metaflow actually persists

In Metaflow, assigning a value to an instance variable inside a step creates a data artifact. Assign self.model, self.results, or self.summary and Metaflow persists it automatically when the step finishes. Local variables that are not attached to self are not persisted.

Every artifact is versioned and stored in the Metaflow datastore, usually object storage such as S3, alongside a snapshot of the code for that run. A metadata service records the run, its steps, its parameters, and where its artifacts live. That gives strong lineage: any past run can be inspected later, its inputs checked, and its outputs reproduced.

Three features build on that storage. The Client API lets code fetch artifacts from a previous run, including from a different flow, if the code knows what to look for. The resume command reuses the results of successful steps from a failed run and only re-executes from the failed step onward. The spin command re-runs a single step using artifacts from the most recent run, or from a run you specify, for quick testing.

So the record is real. The question is who has to go and get it.

What a new run does not do

A new run does not automatically load the previous run's artifacts into the new flow. It starts at start, with the parameters you pass this time, and creates a fresh set of artifacts as its steps complete. If a step needs yesterday's result, your code has to fetch it explicitly through the Client API, pass it in as a parameter, or read it from a store you maintain yourself.

That design is deliberate for data pipelines. A training or data-processing flow should be reproducible from its own inputs, not quietly changed by whatever happened in an earlier execution. Reproducibility is a strength for pipelines. It becomes a gap when the work itself is a continuing conversation.

Consider a scheduled flow that reviews new support conversations each morning, drafts replies, and flags accounts that need attention. Metaflow will faithfully save today's draft list, today's flagged accounts, and today's summary as artifacts. Tomorrow's run will save its own set just as faithfully. Nothing in that mechanism tells tomorrow's AI step that an account was already flagged twice, that a customer already answered the question the draft is about to ask again, or that a human already approved a different wording. Unless code is written to fetch, merge, and re-brief all of that, the AI step wakes up with only this morning's inputs.

Resume does not close that gap. Resume is about finishing one interrupted run, reusing its successful steps. It is not a memory that carries reasoning, decisions, and conversation history forward into the next scheduled run.

The pattern operators end up building by hand

Once an AI step is inside the flow, the missing layer gets built manually, piece by piece. A table stores the last summary. A file in object storage stores open follow-ups. A prompt template pastes in a trimmed history that someone has to keep under a token limit. Another flow, a notebook, or a chat tool outside Metaflow holds decisions that never make it back into the flow at all.

That hand-built store answers a narrower question than the agent actually asks. The agent does not only need the final artifact from last time. It needs the full conversation that produced it: what was asked, what was tried, what a person corrected, and what was settled. An artifact holds the output. The reasoning and the exchange around it usually live somewhere else, or nowhere.

There is also a scope problem. The hand-built store belongs to that one flow. The same operator often runs agents in other tools too, on other schedules, in n8n, Make, or a chat interface. Each place keeps its own partial record, and none of them sees the whole past. The re-briefing tax returns, just spread across more places: paste the context into this run, attach the summary to that one, explain the decision again in the other tool.

A memory layer that sits outside the flow

The clean fix is to give the agent a memory that lives outside any single run and outside any single tool, and let the flow read and write that memory as part of its normal work.

Vilix AI is built for that role. It is cloud-hosted, so there is zero infrastructure to run or maintain: no datastore to provision for memory, no service to keep alive between schedules. The memory is available over MCP, which means the same memory follows the agent everywhere it runs, in a Metaflow step, in another automation tool, and in the AI tools used directly during the day.

Vilix AI stores full conversation history, not just extracted facts or final outputs. When a scheduled agent checks what happened before, it can revisit the actual exchange: the original request, the correction a person made, the decision that followed. That is the material that stops a second run from asking a settled question again or drafting against an instruction that was changed in conversation.

For a Metaflow setup, the shape is simple. At the start of the AI step, the agent retrieves the relevant history for that customer, project, or workflow from Vilix AI. It does its work with that past in view. At the end, it saves the new conversation and outcome back, so the next run, in any tool, starts from the updated record instead of from this run's artifacts alone. Metaflow keeps doing what it does best: versioned artifacts, lineage, resume, and reproducible pipeline execution. The memory layer handles the continuing story between runs.

Control stays plain. Data in Vilix AI can be exported or deleted at any time, so the record an agent relies on is portable and removable, not locked inside one flow's datastore. The free plan is free forever, and the Pro plan offers a 7-day trial with no credit card required, which makes it practical to test the pattern on one scheduled flow before widening it.

The short answer

Does Metaflow remember between runs? It remembers in the archival sense: artifacts, code, parameters, and metadata from every run are persisted, versioned, and retrievable if your code asks for them. It does not remember in the working sense an AI agent needs: a new run does not carry forward the conversation, decisions, and context from the last one on its own.

Save pipeline outputs in Metaflow. Give the agents inside those pipelines a shared memory outside them, and each scheduled run can start where the last one actually left off.

Start at Vilix AI and connect one scheduled flow first.