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

Faktory is a background job server for any language, built around a simple idea: push a job from any client, and a worker in any other language can fetch and run it. A job moves through queues, a working set, a scheduled set, a retries set, and a dead set. For a team whose job does 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. Faktory stores the job payload until a worker runs it, and it records whether that job was acknowledged or failed. The next job still starts with only the arguments it was pushed with. What the last run found, decided, or already handled is not passed along.

A job is a function call, written as JSON

Pushing a job creates a JSON payload. That payload holds a unique job ID, the jobtype that names which worker function should run, the args array that function receives, and the queue it belongs to, which defaults to "default". It can also hold a reservation timeout, a retry count, and a scheduled time. Arguments must be native JSON types: strings, numbers, booleans, maps, arrays, and null. Complex objects from a specific language cannot be passed.

The payload's own documentation describes the model plainly: think of a job as a function invocation, where jobtype is the name of the function and args are its parameters. Read the payload closely and its scope becomes clear. Every field answers an execution question. Which function should run. With which inputs. On which queue. How long a worker may hold it before the reservation expires, which defaults to 30 minutes. How many times it may be retried, which defaults to 25 retries over about 21 days with exponential backoff. 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 it? The job knows how to start. It does not carry a briefing from the job before it.

There is one deliberate opening in that design. A payload can carry a custom hash for arbitrary key and value pairs that middleware needs, set when the job is pushed, and anything outside that hash is discarded. It attaches context chosen in advance by the enqueueing code. It is not a place where a finished job automatically writes what it learned.

Acknowledged means gone, and failed means a debugging note

A worker that finishes a job acknowledges it. Acknowledgement is the success signal, and it closes the job out. Faktory does not capture a return value from the worker and store it as a result for later jobs to read. A job that succeeded leaves no summary behind: not which sources it checked, not which items it skipped and why, not which output a person corrected, and not which lead it already contacted.

Failure is recorded in more detail, and the detail is aimed at the operator, not at the next job. When a job fails, Faktory stores a failure hash inside the payload, with elements such as the error message and, when backtrace retention is enabled, a limited number of backtrace lines. That information is shown in the Web UI, for example when opening a job in the Retries tab. It helps a person debug why a job is retrying. It is not delivered as a briefing to the retry itself, and it is never assembled into a history that a future, separate job can search before it starts. A retry receives the same original jobtype and the same original args, on a backoff schedule, until it succeeds or exhausts its retries and moves to the dead set.

Batches coordinate jobs, they do not brief them

Faktory Enterprise batches can look like shared state, and they are worth reading carefully. Jobs can be pushed as part of a batch, and when every job in the batch completes or succeeds, Faktory queues a callback job. Batches can be nested, and a callback can start the next batch, so ordered steps can be built from concurrent jobs. That is real coordination. It answers when the next step may start.

Coordination is not memory. A batch callback is itself just another job, with its own jobtype and its own args, chosen when the batch was defined. The callback does not receive a merged account of what each job in the batch found. If ten research jobs run in a batch, the callback knows the batch finished. It does not automatically know the ten findings, the duplicates among them, or the one finding a person flagged as wrong. Passing any of that forward still depends on each job writing it somewhere shared, outside the queue, and on the next job reading it back.

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

None of this is a reason to replace the job server. Faktory does the job it promises: language-neutral jobs, queues, reservations, retries, scheduled and dead sets, and a Web UI to inspect them, all in one place. The gap appears when the job 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 job server.

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 Faktory 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. Faktory decides when work happens and runs it reliably. Before the job 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 job 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 job server that stores clean JSON payloads is a strong foundation for scheduled work. Adding one shared memory beside it is what turns a job that merely runs every day into an agent that remembers every day.