Does Procrastinate Remember Between Runs? Jobs Are Stored in Postgres. The Next Job Still Starts With Only Its Arguments.

Procrastinate is a PostgreSQL-based task queue for Python. A function is decorated as a task, calling it in a special way defers a job instead of running the function on the spot, and a worker picks that job up elsewhere, now or in the future. The library supports sync and async code, Django integration, retries, locks, and periodic tasks. For a team whose deferred function does AI work on a schedule, that raises a practical question: when the same task runs again tomorrow, does it know anything about today's run? No. Procrastinate stores the job in Postgres until a worker runs it, and it records how that job ended. The next job still starts with only the arguments it was deferred with. What the last run found, decided, or already handled is not passed along.

What a deferred job actually carries into Postgres

Deferring a task writes a job row. That row holds the task name, the arguments passed at defer time, the queue the job belongs to, its scheduled time, and its priority, along with any lock or queueing lock set for it. A worker reads due rows, claims one, and calls the function with those arguments.

Read that row closely and its scope becomes clear. Every field answers an execution question. Which function should run. With which inputs. On which queue. At what time. Which attempt is this. None of the fields answers a work question: which records did yesterday's run already process, which exception did a person approve, or which conclusion should today's run build on instead of rediscovering? The job knows how to start. It does not carry a briefing from the job before it.

Scheduling follows the same boundary. A job can be deferred for a future time, and that changes when it runs. It does not change what it knows. A job that waits in Postgres for a week arrives at the worker with exactly the arguments it was given on day one, and nothing it could have learned from jobs that completed in between.

A status is kept for the operator, not handed to the next job

Procrastinate does keep one thing after a job finishes: its outcome as a status. Jobs move through a small set of states, from todo when a job is ready to be picked up, to doing while a worker processes it, and then to succeeded or failed. That record is genuinely useful. An operator can query the jobs table, see what is waiting, what is stuck, and what failed, and decide what to do next.

The limits of that record matter for recurring work. A status is a verdict, not a summary. Succeeded says the function returned without raising. It does not say which sources the run checked, which items it skipped and why, which output a person corrected, or which lead it already contacted. And nothing delivers even that verdict to the next job. The queue never looks up the previous firing, reads how it ended, and merges anything into the new job's arguments. A retry follows the same rule: a failed job can be attempted again under its retry settings, and the new attempt receives the same original arguments, not a note about why the last attempt failed.

Periodic tasks repeat the call, and locks guard execution, not knowledge

Periodic tasks make the gap easiest to see. A task registered as periodic with a cron expression is deferred again at each matching time, for example once a day. The schedule is real and reliable. What repeats is the call itself, with the same setup each time. Tuesday's firing does not open Monday's run, summarize it, and brief itself before starting.

Locks can look like shared state, and they are worth reading carefully. A lock means that jobs sharing the same lock value cannot be in the doing state at the same time. A queueing lock means only one job with that value can sit in the queue as todo at once. Both are coordination tools. They stop two copies of a job from colliding. Neither one stores anything a finished job learned, and neither one adds that learning to the next job's inputs. A lock answers who may run now. It never answers what the last run already knows.

The missing layer is shared memory, and it sits beside the queue

None of this is a reason to replace the queue. Procrastinate does the job it promises: durable jobs in a database the team already runs, workers that pick them up, retries and locks and schedules handled in one place. The gap appears when the deferred function is an AI agent step in a recurring automation, because that step needs a past, not just a trigger. It needs to start each run already knowing what previous runs established, across every tool in the workflow, not only inside one queue.

That past is what Vilix AI provides as a shared memory layer. Vilix AI is cloud-hosted, so there is zero infrastructure to run or maintain: no extra database to provision, no memory service to deploy next to the worker. The same memory is available everywhere over MCP, so the Procrastinate worker, the chat tool used to review its output, and every other connected agent read and write one shared memory instead of separate local notes. And Vilix AI stores full conversation history, not just extracted facts, so a run can revisit what was actually said and decided, in context, rather than working from a compressed summary.

In practice the split is simple. Procrastinate decides when work happens and runs it reliably. Before the task acts, it checks Vilix AI for what earlier runs already found, which items are already handled, and which corrections a person already gave. After the task finishes, it saves its findings back, so the next firing, on any schedule and in any tool, starts briefed instead of blank.

Getting started carries no commitment. Vilix AI has a free plan that is free forever, and a 7-day Pro trial with no credit card required. Data stays under the operator's control, with the ability to export everything or delete it anytime. A queue that stores jobs in Postgres is a strong foundation for scheduled work. Adding one shared memory beside it is what turns a task that merely runs every day into an agent that remembers every day.