Does RabbitMQ Remember Between Runs? Messages Wait in Queues. The Next Run Still Starts With Only Its Message.

RabbitMQ is a message broker. A producer publishes a message to an exchange, the exchange routes it to one or more queues, and a consumer takes it from a queue and processes it. For a team whose consumers do AI work on a schedule, that raises a practical question: when the same kind of message arrives again tomorrow, does the consumer know anything about today's run? No. RabbitMQ stores each message exactly as it was published, as a body with properties and headers fixed at publish time. The next message still starts with only what its producer wrote into it. What the last run found is not passed along.

A message is published to an exchange, and the broker never adds to it

A message in RabbitMQ is never sent directly to a queue. It is published to an exchange with a routing key, and the exchange copies it into queues according to its bindings. A direct exchange routes on an exact key match, a topic exchange matches key patterns, and a fanout exchange copies the message to every bound queue. Routing decides where a message waits. It does not decide what the message knows.

The message itself is a byte body plus properties such as content type, delivery mode, and priority, plus any headers the producer set. The broker moves that package faithfully. It does not read the body's meaning, summarize it, or update it after a consumer acts on it. Two consumers bound to different queues can receive copies of the same message and reach opposite conclusions about it, and RabbitMQ records neither conclusion. The exchange and its bindings organize where work waits. They do not organize what work learned.

The ack deletes the message, and its result goes nowhere

Delivery ends in one of the clearest signals in messaging. With manual acknowledgements, the consumer sends an ack once processing succeeds, and RabbitMQ deletes the message. That deletion is the whole result handling RabbitMQ defines for a queue. There is no result store, no return value kept for the next message, and no summary merged into a future message on the same queue.

The failure paths describe delivery problems, not learning. If a consumer dies before acking, RabbitMQ requeues the message and redelivers it to another consumer, unchanged. A nack or reject can send a message back to the queue or, with requeue set to false, drop it or route it to a dead letter exchange. A message that sits past its time to live expires and is dropped or dead-lettered the same way. Every one of those moves answers an execution question: should this exact message be delivered now, again, later, or parked where a person can look at it?

Dead letters look like a record, and they are worth reading precisely. A dead letter queue holds messages that were rejected, expired, or pushed out by a queue length limit, and the broker adds headers recording why the message died, from which queue, and how many times. That is an operations trail about the message's delivery. The finding the consumer produced before rejecting, what it checked, what it decided, and what a successor should skip, is not in there, because the consumer never handed it to the broker.

Durability protects waiting messages, not what finished work learned

RabbitMQ offers real durability, and it is aimed at messages that have not been processed yet. A durable queue survives a broker restart, and a message published as persistent, with delivery mode set to 2, is written to disk so it can survive with it. Both settings together protect waiting work across a crash or a deploy. Quorum queues go further and replicate messages across a cluster using Raft, so a node failure does not take the queue's waiting messages with it.

Either way, durability answers a delivery question. A waiting message still arrives after a restart, an unacked message is still redelivered, and a replicated queue still holds what was published to it. Durability does not add a memory of completed work. A message that was consumed, processed, and acked before the restart leaves no briefing behind for its successor. The disk and the replicas protect messages that have not finished. They do not remember for messages that have.

Consider a scheduled AI consumer working a RabbitMQ queue. On Monday it triages a batch of support tickets, routes two of them to billing with reasons, resolves a third from an answer given last week, and notes that a fourth is a duplicate of an open case. On Tuesday new messages arrive with the same shapes. Without an outside memory, the consumer triages from scratch, can route the same customer to the wrong team again, and has no record that the duplicate was already identified. The delivery is correct. The work is repeated, because each message arrives alone.

What a scheduled RabbitMQ consumer actually needs

The missing piece is not a better exchange. RabbitMQ already does the broker job well: flexible routing, acknowledgements and redelivery, dead letter handling, and durable and replicated queues for waiting work. The missing piece is a memory that sits outside any single message, that a consumer can read before it acts and write to when it finishes, and that every other tool in the workflow can also reach.

That memory 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 broker. The same memory is available everywhere over MCP, so the consumer that takes the message, 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 consumer changes shape. Before it triages anything, it loads what Monday's run saved: which tickets were routed where and why, which one was resolved, and which one was already a duplicate. It spends its time on what is new, then saves its own findings back, so Wednesday's run starts briefed as well. The queue still delivers the message. 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. For a scheduled consumer that redoes finished work, that is the simplest test: give the next message the last run's memory and watch repetition disappear.

RabbitMQ will keep routing each message to its queue unchanged. The question is only whether the consumer arrives alone. With a shared memory layer beside the broker, it arrives knowing what the run before it learned.