Does Cadence Remember Between Runs? History Replays Inside One Workflow. The Next One Starts Fresh.

Short answer: Cadence remembers a great deal inside one workflow execution. Its history can replay that execution after a worker failure and rebuild its state exactly. A separate execution, started tomorrow or started by a schedule, begins with only the inputs it was given. It does not read the previous execution's history and brief itself.

That line is easy to miss, because Cadence persistence is genuinely strong. Persistence inside an execution and memory across executions are two different jobs, and only the first one belongs to Cadence.

What Cadence actually keeps

Cadence is Uber's open-source orchestration engine, open sourced in 2017, built to coordinate long-running work across microservices. Instead of asking application code to save its own checkpoints, Cadence keeps an event history for every workflow execution. Each step, timer, signal, and activity result is recorded as an event, and that history is the source of truth for the execution.

Inside one execution, that design delivers real continuity:

• State survives worker failure. If a worker dies mid-workflow, another worker replays the history and recreates the workflow state, including local variables and where execution stopped. Workflow code does not need failure-recovery code for that case.
• Signals are durable. A signal sent to a running workflow is persisted in its history with its payload, so the workflow can process it later without the information being lost.
• Queries read live state. A running workflow can expose query handlers, so an operator or another service can ask for its current state, or inspect its stack trace, while it is still open.
• Timers persist. Sleeps and timers are handled by Cadence itself, so a workflow can wait for days and still resume at the right point in the same execution.

All of that belongs to one execution, identified by its workflow ID and its run ID. Change the run, and the history is a different history.

The one narrow bridge between executions

Cadence does offer one deliberate bridge, and naming it precisely matters. A workflow that finishes can hand its completion result to the next execution in a chain, for example when a long-running workflow restarts itself using ContinueAsNew to keep its history from growing without limit. The next execution can read that last completion result and start from it.

That bridge carries exactly what the workflow code chose to return, and nothing else. It is a single result value passed forward by design, not a store the new execution searches. Conclusions that were never packed into that result, context from other workflows, and anything learned by a different tool stay outside it.

Starting a workflow the ordinary way is simpler and emptier. A scheduled start, a manual start, or a start from another service supplies start parameters. Those parameters are the whole briefing. Yesterday's execution may have spent hours learning which records were duplicates, which account was on hold, and which exception a human approved for one case only. None of that arrives unless custom code fetched it, condensed it, and placed it into today's parameters.

History you can inspect is not memory a run can use

After an execution closes, its history remains valuable. Teams replay a failed execution under a debugger, review what happened in what order, and use visibility tools to list and inspect past executions. For audits and post-mortems, that record is exactly the right tool.

A record answers: what did that run do? Memory for the next run has to answer a different question: what should be known before acting today?

Nothing in the start path reads the old history back in as context. Tonight's workflow does not open last night's history, work out which parts still matter, and fold them into its first decision. A human or a hand-built integration has to do that translation, run by run, field by predicted field.

Place a scheduled AI agent inside that pattern and the gap becomes concrete. Every night an agent reviews new support cases, checks them against account records, and routes what needs attention. On Monday it learns that one contact asked for a pause, one issue was already resolved in another channel, and one workaround was approved for a single account. On Tuesday a new execution starts with a date range as its parameters. The agent checks the paused contact again, reopens the resolved issue in its routing, and has no reliable way to know the workaround was a one-off.

The layer that carries Monday into Tuesday

Vilix AI is a separate memory layer built for that handoff. A workflow step running under Cadence, an agent in another orchestrator, and a tool used in an interactive session can all read and write the same memory over MCP, so the next execution starts with the shared past available instead of reconstructing it from a closed history.

Vilix AI is cloud-hosted with zero infrastructure to run. There is no history store, results table, or sync job to operate for the memory itself. The same memory follows work everywhere over MCP, which means a conclusion saved on Monday can be read on Tuesday by the next execution and by any other connected tool, not only inside one Cadence domain.

The memory holds full conversation history, not just extracted facts. When a later run needs to know why an account was paused, it can revisit what was actually discussed and decided, rather than trusting a single status field. That fuller record is what makes it safe to reverse a decision when the customer writes back and circumstances change.

Vilix AI has a free plan forever, plus a 7-day Pro trial with no credit card. Data stays portable, with export and delete available anytime. One scheduled workflow is enough to test the pattern: save what tonight's run learns, then check what tomorrow's run already knows before it acts.

The question to ask about any orchestrator

Take one fact tonight's run will learn and follow it. If that fact ends up sealed inside a closed execution's history, or travels only because code packed it into a completion result or a start parameter, the system has durable history, not shared memory.

Cadence is strong at the job it was designed for: durable, replayable execution that survives worker failure. Give the agent running on top of it a memory layer designed to carry context between executions, and each system handles the part it does best.

Give your scheduled agents one shared memory with Vilix AI so the next execution starts informed, not just on schedule.