Does ZeroMQ Remember Between Runs? There Is No Broker and No Store. The Next Run Still Starts With Only Its Message.

ZeroMQ remembers almost nothing, and that is by design. ZeroMQ is not a broker and it is not a server. It is a messaging library that runs inside an application process and gives that process sockets that act like smarter network sockets. Peers connect directly to each other, messages move from one process to another, and there is no central place where messages are filed away. A message lives in memory, in a queue attached to a socket, for as long as it takes to hand it over. What a run did with that message was never recorded anywhere, so the next run starts with a message, and nothing else.

There is no broker to keep anything

Most messaging systems have a middle box that can hold messages while receivers are away. ZeroMQ removes that box on purpose. An application creates a context, opens sockets, and binds or connects them over transports such as TCP, inter-process IPC, or in-process inproc between threads. Background I/O threads inside the process move the bytes.

That shape brings speed and simplicity. It also decides the memory question before it is asked. Storage needs somewhere to live, and in a brokerless design there is no independent process whose job is to keep a log, a queue file, or a history. Each side keeps only what its own sockets are currently holding. When the process ends, everything its sockets were holding ends with it.

The socket patterns show the same intent. Request-reply routes a request and fair-queues replies. Publish-subscribe fans a message out to current subscribers. A pipeline pushes work down a line of workers. An exclusive pair connects two sockets one to one. None of these patterns adds a store, an acknowledgement ledger, or a replay log. They are ways to move messages, not ways to remember them.

A queue in memory is the whole of the storage

What a socket does hold is an in-memory queue per connected peer. A send does not normally write straight to the network. The message is placed in the queue, and the I/O threads deliver it as the peer accepts it. A matching queue on the receiving side holds incoming messages until the application reads them.

Two settings bound that holding. The high water mark, set separately for sending and receiving, caps how many messages a queue may hold for one peer, with a default of 1,000. What happens at the cap depends on the pattern: some sockets block the sender, and others, including publish-subscribe, drop messages instead. The linger setting controls the other end of the life cycle. It decides how long a closing socket keeps trying to flush messages that are still queued. A linger of zero discards unsent messages at once.

Both settings underline the same point. The queue is a buffer for delivery that is in progress, not a record of delivery that already happened. A publisher with no connected subscribers drops its messages rather than saving them for later. A queue that holds a message while a peer reconnects holds it only while the sending process stays alive and only up to the high water mark. Close the process, or exceed the cap, and there is nothing left to recover, because nothing was ever written to disk or handed to a store.

Reliability, where a design needs it, is built at the application level. Acknowledgements, retries, and request resending are patterns an application adds over the sockets. Those patterns can make delivery robust while a run is alive. They still leave no shared history behind for the next run to read.

What a scheduled agent actually needs at the start of a run

Consider a scheduled automation whose steps talk over ZeroMQ sockets, inside an n8n, Make, or Zapier flow, or in a custom agent. At the start of a new run, the next message is only one part of what that run needs. It also needs to know which earlier messages were already investigated, so a repeated delivery or a rebuilt pipeline does not trigger the same action twice. It needs the decisions made on those messages, so a pattern cleared yesterday is not treated as brand new today. It needs the full reasoning behind those decisions, so a genuinely new message that looks similar can be separated from a settled one. And it needs that record shared, so a second workflow using the same sockets starts from the same past.

ZeroMQ supplies the transport, the patterns, the in-memory queues, and automatic reconnection. The rest is memory, and memory belongs in a layer built to hold it.

That layer is what Vilix AI provides. Vilix AI is cloud-hosted, with zero infrastructure to run: no broker, store, or extra socket service to provision beside the existing setup. The same memory is available everywhere over MCP, so the automation receiving the message, the agent reviewing the outcome, and every other connected tool read and write one shared memory. Vilix AI stores full conversation history, not just extracted facts, so a later run can revisit what was actually discussed and decided, in context, instead of working from a single new message or a short summary.

The practical split is simple. Let ZeroMQ do the job it is built for: connecting peers directly, queuing in memory up to the high water mark, and moving messages with very little overhead. At the end of each run, write the outcome into memory: what arrived, what was checked, what was decided, and what still needs attention. At the start of the next run, read that memory before acting. A repeated message then meets an agent that can check the record of work first, recognize finished work, and spend the run only on what is genuinely new.

There is no cost to testing that split. Vilix AI has a free plan that stays free forever, and Pro comes with a 7-day trial that needs no credit card. The memory stays portable throughout: export everything or delete it anytime.

Get Started for Free Free forever, no credit card.

ZeroMQ will carry the next message between processes, fast and brokerless. The memory makes sure the next run arrives knowing everything the earlier runs learned.