Does Celery Remember Between Runs? Results Are Stored, the Next Task Still Starts Fresh.

Celery keeps careful records about tasks. It tracks whether a task is waiting, running, finished, or failed, and it can store the value a task returned. None of that gives the next scheduled task the context the last one worked with. The distinction matters once a task contains an AI step that has to follow up or draft based on what happened last time.

What Celery actually keeps

Start with the scheduler. Celery Beat is a separate process that reads a schedule, works out which tasks are due, and publishes a message to the broker for each one. Beat does not run tasks itself. Workers pick the messages up and execute them. To do that job across restarts, Beat's default PersistentScheduler stores the last run time of each entry in a local file, usually called celerybeat-schedule. Database-backed schedulers, such as django-celery-beat, store the same information in database rows instead, including last_run_at and total_run_count.

Next, the result backend. When a task finishes, Celery can store its state and return value in a backend such as Redis or a database. Each record is keyed by that task's own ID. Code that knows the ID can build an AsyncResult, check the state, and read the result or the traceback after a failure. The built-in states cover the life of one task: PENDING, STARTED when tracking is enabled, SUCCESS, FAILURE, RETRY, and REVOKED. Results also expire, and a built-in cleanup task removes old results so the store does not grow without limit.

Worker state is narrower still. A worker started with a statedb file persists only its list of revoked task IDs between restarts. That is operational housekeeping, not a history of what tasks decided.

So Celery keeps three kinds of record: when an entry last fired, how one identified task ended, and which IDs were revoked. All three are useful. None is loaded into the next task on its own.

What the next task starts with

A new task invocation starts with the arguments in its message. That is the whole briefing. If a scheduled job runs every morning with the same arguments, every morning's task receives the same starting point, no matter what yesterday's task learned, promised, or corrected.

Nothing in the result backend changes that by itself. Yesterday's return value sits under yesterday's task ID. Today's task does not search the backend for relevant past work, merge it into a briefing, and continue from it. Code you write has to do every step of that retrieval: know which IDs matter, fetch them before they expire, turn stored return values back into context, and handle the cases where the result was never stored or has already been cleaned up.

Beat's schedule file does not help here either. Knowing that an entry fired at 7 a.m. yesterday says nothing about what the task found, what a person replied, or which follow-up is now overdue. The timestamp proves the schedule ran. It carries no working memory forward.

Consider a scheduled task that checks open support threads each morning and drafts replies with an AI model. Celery will record that today's task succeeded and store its return value, perhaps a count or a summary string. Tomorrow's task starts from its arguments again. It does not know that one customer already answered yesterday's question, that a human rewrote one draft and explained why, or that another thread was promised a follow-up today. It can easily draft the same question again, in fresh wording, with complete confidence.

The store operators end up building by hand

The usual response is to build the missing layer inside the application. A database table holds the last summary per customer. A Redis key holds open items. A prompt builder queries recent rows, trims them to fit, and pastes them into today's task. Together they become a second system to design, test, and keep correct as the schedule and the model change.

That store also captures less than the agent needs. A summary row is the end of a run, compressed. The next decision often depends on the middle: the original request, the option that was rejected, the correction a person gave, and the reason a decision went one way instead of another. If only the final output was saved, the next run gets the conclusion without the exchange that produced it.

Scope is the other limit. The table belongs to that one Celery application. The same operator usually runs agents in other places too: another queue, an n8n or Make scenario, and AI tools used directly. Each place keeps its own partial record, and a decision made in a chat tool never reaches the morning Celery task unless someone copies it across.

A memory that lives outside the task

The cleaner shape is to keep task execution in Celery and give the agent a memory that lives outside any single task, application, or tool, which every run reads at the start and updates at the end.

Vilix AI is built for that layer. It is cloud-hosted with zero infrastructure to run, so there is no extra store to provision or keep alive between schedules. It is available over MCP, so the same memory follows the agent across a Celery worker, another automation platform, and the AI tools used directly. One memory, reachable everywhere the work happens.

Vilix AI stores full conversation history, not just facts or final results. A scheduled agent can revisit the actual exchange: what was asked, what was tried, what a person corrected, and what was settled. That history is what stops a second run from asking a settled question again, sending a follow-up that was already sent, or drafting against an instruction that changed in conversation yesterday.

In a Celery setup the pattern stays small. At the start of the task, the AI step retrieves the relevant history for that customer, project, or workflow, does the work with the past in view, and saves the new exchange and outcome back before the task ends. Beat keeps scheduling, workers keep executing, and the result backend keeps recording task states. The continuing story lives in the memory layer, where the next run in any tool can find it.

Data in Vilix AI can be exported or deleted at any time. The free plan is free forever, and Pro offers a 7-day trial with no credit card required, so the pattern can be tested on one periodic task first.

The short answer

Does Celery remember between runs? In the bookkeeping sense, yes: Beat remembers when entries last fired, the result backend remembers how identified tasks ended until results expire, and workers can persist revoked IDs. In the working sense an AI agent needs, no: the next task receives only its arguments and starts fresh unless your own code fetches and rebuilds the past for it.

Let Celery do scheduling and execution. Give the agents inside those tasks a shared memory outside them, and each run can start where the last one actually left off.

Start at Vilix AI and connect one periodic task first.