Does Redis Streams Remember Between Runs? Entries Stay in the Log Until Trimmed. The Next Run Still Starts With Only Its Entry.

Redis Streams remembers more than most Redis structures do. A stream is an append-only log under a single key. Entries stay after they are read, consumer groups track delivery and acknowledgement, and unacknowledged entries left by a crashed consumer can be handed to a healthy one. That is a real delivery record. It is not a record of the work itself. An entry holds the fields a producer wrote, in the order they were appended. What a run checked, decided, and finished after reading that entry was never written back to the stream, so the next run starts with an entry, and nothing else.

A stream keeps entries, in order, under one key

Producers append entries with XADD. Each entry receives an ID made from a timestamp and a sequence number, so entries sort in the order they arrived. Each entry holds a set of field-value pairs, and once written an entry is never changed. Readers keep their own position in the log, because reading does not remove anything.

Read directly with XREAD and the server keeps no state at all: every reader sees every entry, and each reader tracks where it stopped on its own. Consumer groups add the bookkeeping. A group created with XGROUP CREATE starts from a chosen ID, either the beginning of the stream or only entries that arrive afterwards. Inside the group, XREADGROUP with the special greater-than ID delivers entries that were never delivered to any member of that group before. Each entry goes to one consumer in the group, not to all of them, so the work is split instead of duplicated.

That split is why streams replaced plain lists as a work queue in many setups. Popping a list removes the item and leaves no trace. A group delivery leaves a trace, and that trace makes recovery possible.

The pending list remembers delivery, not completion of the work

When a group delivers an entry, Redis records it in the group's Pending Entries List, the PEL. The pending record holds the entry ID, the name of the consumer it was delivered to, the delivery time, and a delivery count. The entry stays pending until that consumer acknowledges it with XACK. Acknowledgement removes the pending record. The entry itself stays in the stream, because only trimming or an explicit delete removes entries.

The PEL answers three useful questions. XPENDING shows how many entries are still unacknowledged, and which consumers hold them. A restarted consumer can re-read its own pending entries by reading with ID 0 instead of the greater-than ID. An entry pending too long can be moved with XCLAIM, or reassigned automatically with XAUTOCLAIM once it has been idle past a chosen minimum time. Delivery is therefore at-least-once: an entry is handed out again until someone acknowledges it, and handlers must tolerate seeing the same entry twice.

None of that records what the handler concluded. The PEL knows an entry was delivered twice and acknowledged once. It does not know what the run found while processing it, what decision followed, what action was taken outside Redis, or whether that action succeeded. Once the acknowledgement lands, even the delivery trace is gone, and the group remembers only its position in the log.

Retention is a trimming decision, not a record of work

A stream has no built-in expiry. Without trimming, entries stay available for replay indefinitely, and any consumer or group can re-read the log from any earlier ID. That replay is valuable: a new reporting job can be built from history, and an investigation can re-read the exact entries a decision was based on.

Size is controlled by trimming, usually a maximum length on XADD or an XTRIM by length or by minimum ID. Approximate trimming keeps the operation cheap, at the cost of keeping a few entries past the cap. Trimming also ignores the pending list: an entry can be trimmed while still pending, so a recovering consumer can be handed an ID whose payload no longer exists. XAUTOCLAIM surfaces those missing IDs in its deleted list. The log's retention policy and the work's recovery needs are separate concerns, managed separately.

Replay, in any case, returns the starting point, not the ending point. The entry that comes back is the entry that was written, unchanged. It carries no note about which runs handled it, what was checked alongside it, or what was settled because of it.

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

Consider a scheduled automation that consumes a stream through n8n, Make, Zapier, or a custom agent. At the start of a new run, the next entry is only one part of what that run needs. It also needs to know which earlier entries were already investigated, so a replay, a restart, or a reclaimed pending entry does not trigger the same action twice. It needs the decisions made on those entries, so a pattern cleared yesterday is not treated as brand new today. It needs the full reasoning behind those decisions, so a genuinely new entry that looks similar can be separated from a settled one. And it needs that record shared, so a second workflow reading the same stream starts from the same past.

Redis Streams supplies the entries, the order, the delivery tracking, and the replay window. 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 extra stream, consumer group, or pending list to provision beside the existing setup. The same memory is available everywhere over MCP, so the automation consuming the stream, 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 replayed entry or a short summary.

The practical split is simple. Let the stream do the job it is built for: appending entries in order, splitting deliveries across a group, tracking acknowledgements, and replaying history inside the retention window. 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 redelivered entry 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.

The stream will keep the next entry, in order, for as long as the trimming policy allows. The memory makes sure the next run arrives knowing everything the earlier runs learned.