Does Cloudflare Queues Remember Between Runs? A Message Is Held Until It Is Acknowledged or Expires. The Next Run Still Starts With Only Its Message.

Cloudflare Queues remembers a message for exactly as long as delivery requires, and no longer. A producer Worker sends a message, the queue holds it durably, and a consumer Worker receives it in a batch, does the work, and acknowledges it. Acknowledgement deletes the message. That lifecycle is reliable delivery memory, built carefully and on purpose. What the queue never keeps is anything the consumer learned while doing the work, so an AI agent fed by Cloudflare Queues still starts every run with only the message in front of it.

A global queue built to hand work over safely

Cloudflare Queues is a managed message queue that runs on Cloudflare's global network. A producer drops a message on a queue and returns immediately, without waiting for the work to happen. A separate consumer, usually another Worker or an HTTP pull consumer, picks messages up later and processes them in the background. The two sides never need to run at the same speed, handle the same load, or even be healthy at the same moment.

Each message is small by design: up to 128 KB, which suits job instructions, identifiers, and compact payloads rather than documents or files. A queue can move up to 5,000 messages per second, and a single queue can hold a backlog of up to 25 GB while consumers catch up. Those numbers describe a buffer that scales. They do not describe a record of completed work.

Retention makes the intent explicit. A message stays in the queue for a configurable retention period, from 60 seconds up to 14 days, with 4 days as the long-standing default and 24 hours as the maximum on the free plan. When a message reaches the end of that period unconsumed, the queue deletes it. Every part of that setting answers a delivery question: how long should undelivered work be allowed to wait? Nothing in it preserves knowledge after delivery succeeds.

Acknowledgement deletes, and failure only brings the message back

The consumer pattern shows what kind of memory this is. Queues delivers messages to a push consumer in batches, and the handler finishes each message in one of two ways. Calling acknowledgement tells Cloudflare the work is done, and the message will not be delivered again. Throwing an error, or calling retry on a message, tells Cloudflare to deliver that same message again later, after an optional delay.

Delivery is at-least-once, which means the same message can legitimately arrive twice. The classic case is a consumer that completes the work and then stops before the acknowledgement lands. Cloudflare cannot know the work finished, so it delivers the message again, and consumer code is expected to make a second processing harmless. Retries are capped by a configured maximum, up to 100 attempts, and a message that exhausts its retries moves to a dead letter queue when one is configured, where it waits for inspection instead of vanishing.

Read those safeguards together. Batching, acknowledgement, retry delays, and the dead letter queue all protect the message. None of them protects the learning. A message that succeeds is deleted along with the only queue-side trace that the work happened. A message that fails returns in its original form, with no note about why it failed, what was already tried, or how far the work got before it stopped. Pull consumers follow the same shape with a lease: a pulled message stays exclusively held for a visibility timeout of up to 12 hours, and the lease expiring simply makes the original message available again.

What this means for a scheduled AI agent

Consider a common automation shape on Cloudflare. Events, form submissions, or scheduled jobs land on a queue. A consumer Worker receives a batch and passes each payload to an AI agent step. The agent does substantive work: it checks account history, weighs an exception against past cases, chooses a next step, drafts a reply, and updates another system. Then the consumer acknowledges the message, exactly as the pattern requires.

The next message arrives an hour later, or the next morning. The agent sees a fresh payload of at most 128 KB. It does not see that the same customer raised the same issue last week, that the same exception was already approved twice, or that the winning move last time was to escalate instead of replying. The queue performed perfectly. Every message was stored safely, delivered at least once, retried when it needed to be, and deleted when it was done. The gap sits one level above the queue, in the space where run-to-run knowledge should live.

Operators often try to close that gap inside the message itself, packing summaries and prior decisions into the next payload, or rebuilding context in a separate database keyed by hand. The payload approach caps out at 128 KB and only helps when the producer already knows what the next run will need. The hand-built store works until a second tool, a second queue, or a second agent needs the same history and finds a schema built for one consumer. Delivery memory answers whether the message arrived. Agent work depends on what has been learned so far. Those are two different jobs, and they need two different systems.

Give the agent a memory that outlives the message

Vilix AI is the shared memory layer that sits beside the queue and keeps what the queue deletes. Where Cloudflare Queues removes a message on acknowledgement, Vilix AI keeps the full conversation history, not just extracted facts, so the reasoning behind a decision stays readable next to the decision itself. The next run does not need a fatter payload. It retrieves the relevant past at the start of the run.

Vilix AI is cloud-hosted with zero infrastructure to run: no queue to tune for memory, no database to provision, and no retention window to gamble on. Agents connect over MCP, so the same memory follows the work everywhere, from a queue consumer Worker on Cloudflare to an n8n flow, a Make scenario, or a chat session the next day, across tools and devices. Every step reads and writes one shared state instead of a separate summary hidden inside a message body.

The working pattern stays simple. Messages still travel through Cloudflare Queues, which remains the right tool for durable, decoupled, at-least-once delivery. At the start of a run, the agent step pulls its context from Vilix AI. At the end of the run, it saves what it did, what it decided, and what it noticed. The queue forgets on acknowledgement, exactly as designed, and the agent forgets nothing, exactly as required.

Starting takes minutes. The free plan is free forever, and the 7-day Pro trial needs no credit card. Data stays under full control, with export of everything or deletion of everything available at any time. Let Cloudflare Queues remember the message until it is delivered. Let Vilix AI remember everything the delivery taught the agent.