Does Resque Remember Between Runs? Jobs Are Stored as JSON in Redis. The Next Job Still Starts With Only Its Arguments.

Resque is a Redis-backed library for creating background jobs in Ruby, placing those jobs on multiple queues, and processing them later. A job is any Ruby class or module that responds to perform. For a team whose jobs do AI work on a schedule, that raises a practical question: when the same job runs again tomorrow, does it know anything about today's run? No. Resque stores the job as a simple JSON package in Redis. The next job still starts with only the arguments it was enqueued with. What the last run found, decided, or already handled is not passed along.

A job is a JSON package on a Redis list

Calling Resque.enqueue with a job class and its arguments pushes a JSON object onto a Redis list for that queue. The package holds the class name and the arguments, and the arguments must be values that can be JSON encoded. That is a deliberate choice. Passing an id instead of a full record means the job loads fresh data when it runs, rather than working from a stale copy frozen at enqueue time.

A worker reserves a job from the queue, then calls perform with exactly those arguments. Workers can be distributed across machines, they work queues in the order given to them, and the built-in web frontend shows what workers are doing, what is sitting in each queue, and what has failed. Every part of that design answers an execution question. Which class should run. On which queue. With which arguments. None of it answers a work question: which accounts did yesterday's run already review, which exception did a person approve last week, or which conclusion should today's run build on instead of rediscovering it?

The arguments are also fixed in advance by the code that calls enqueue. They can carry context chosen beforehand, such as an account id or a date range. They are not a channel where a finished job automatically writes what it learned for the next job to pick up. If the enqueueing code does not already know a fact at enqueue time, the next job does not learn it from Resque.

A finished job leaves the queue, and its findings leave with it

Once a worker reserves a job, the job comes off the queue list. When perform finishes successfully, there is no result record handed to the next job on that queue. Resque does not keep a return value as a briefing, does not merge the last run's output into the next run's arguments, and does not search past jobs to summarize what they established.

Failure is recorded, and that record shows the boundary clearly. If a job raises an exception, the failure is logged through the failure module, by default in Redis, with the job, its arguments, and the error. A person can inspect failures in the web interface and requeue a failed job. A requeued job runs again with the same class and the same arguments as the failed attempt. That is the right design for a transient error, such as a rate limit or a dropped connection. It is not a way to tell the retry what the first attempt managed to finish before it failed, or what a person decided after reading the error.

So the history Resque keeps is an operations history: what is queued, what is running, and what failed. It is built for a person checking the health of the queues. It is not assembled into a handover that the next job reads before it starts.

Recurring work comes from a separate scheduler, with fixed arguments

Core Resque has no built-in recurring schedule. Recurring work comes from the companion resque-scheduler extension, which adds delayed jobs and scheduled jobs. A schedule is a list of job classes with arguments and a frequency in crontab syntax, usually stored in a YAML file and loaded when the scheduler starts. On each tick, the scheduler enqueues the same class with the same configured arguments.

That makes the timing durable, and it also makes the starting point identical every time. A nightly AI review enqueued this way receives the same shape of input on day thirty that it received on day one, unless the application code itself went and fetched new context from somewhere. The scheduler remembers when. It does not remember what the last run learned.

Consider what that means in practice for a scheduled AI job. On Monday the job reviews a set of accounts, flags three anomalies, and notes that one of them was already explained in a support conversation. On Tuesday the job runs again from its configured arguments alone. Without an outside memory, it reviews the same accounts from scratch, flags the same three anomalies, and has no record that one was already explained. The work is correct in form and repeated in substance, because each run starts blank.

What a scheduled Resque job actually needs

The missing piece is not a better queue. Resque already does the queue job well: persistent queues in Redis, atomic push and pop, visibility into queued and failed work. The missing piece is a memory that sits outside any single job, that a job can read before it acts and write to when it finishes, and that every other tool in the workflow can also reach.

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 and no memory service to deploy next to the workers. The same memory is available everywhere over MCP, so the Resque 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.

With that layer in place, the Tuesday run changes shape. Before it reviews anything, it loads what Monday's run saved: which accounts were covered, which anomalies were flagged, and which one was already explained. It spends its time on what is new. When it finishes, it saves its own findings back, so Wednesday's run starts briefed as well. The queue still delivers the job. The memory delivers the briefing.

Vilix AI is free forever on the free plan, and the 7-day Pro trial needs no credit card. Everything saved can be exported or deleted at any time, so trying it on one recurring job carries no lock-in. For a scheduled job that currently redoes finished work, that is the simplest test: give the next run the last run's memory and watch how much repetition disappears.

Resque will keep storing each job as JSON in Redis and running it with its arguments. The question is only whether the job arrives alone. With a shared memory layer beside the queue, it arrives knowing what the job before it learned.