Does Azure Event Hubs Remember Between Runs? Events Stay in the Partitioned Log for Up to 90 Days. The Next Run Still Starts With Only Its Event.

Azure Event Hubs remembers the event, in full, in the log. An event hub is an append-only log that stores events, producers add new events to the end of a partition, and those events stay there for the whole retention period whether anyone read them or not. That is real retention, and it is stronger than a queue that deletes on delivery. What Event Hubs never keeps is everything around the event: why it arrived, what the last run concluded while handling the previous one, and what should happen differently this time. The next run still starts with only its event.

An event hub is a set of ordered logs, not a queue

Event Hubs organizes the events sent to an event hub into one or more partitions. A partition can be thought of as a commit log: an ordered sequence where newer events are added to the end. Partitions hold the body of the event, a user-defined property bag describing it, and metadata such as its offset in the partition, its sequence number, and the service-side timestamp at which it was accepted.

That design explains both the strength and the limit of Event Hubs memory. The strength is scale with order: many partitions let producers and consumers work in parallel while events that share a partition key stay in arrival order inside their partition, and the hub is equivalent to a Kafka topic. The limit is scope. The partition records event bodies and properties, in arrival order. It does not record processing. Nothing in it notes what a consumer concluded, which branch it took, or what it promised to do next.

Reading an event does not remove it

In Event Hubs, consumption is a position, not a deletion. A consumer group is an independent view of the event stream, and multiple consumer groups can read the same event hub at the same time, each tracking its own position. An offset is the position of an event within a partition, and checkpointing is when a consumer saves its current offset so it can resume from where it left off after a disconnect or a restart.

Two details matter here. First, the checkpoint is the consumer's own responsibility: the service provides offsets, but consumers must store checkpoints themselves, commonly in Azure Blob Storage when the processor clients are used. Second, because reading never deletes, replay works. A consumer can specify an earlier offset and process historical events again inside the retention window, the standard recovery after a bad deploy or a downstream outage.

Replay is still not memory. Re-reading the same event gives the next run the same starting point as the last run, not the accumulated knowledge of the last run. If the previous attempt already checked three sources, ruled out two causes, and narrowed the problem to one device, the replayed event contains none of that. The work starts over from the same square, only later.

The clock deletes by age, not by understanding

Retention in Event Hubs is a time-based policy, and events are automatically removed when it expires. They cannot be explicitly deleted, and a retention change applies to existing events too. On the Standard tier, retention can be set up to 7 days. On the Premium and Dedicated tiers, it can be set up to 90 days. The number matters less than the principle behind it: the log keeps events for a window sized for delivery problems, consumer lag, and short-term replay. It was never sized, or shaped, to be the long-term memory of the systems consuming from it.

Event Hubs Capture stretches the archive, not the memory. Capture automatically saves streaming data to Azure Blob Storage or Azure Data Lake Storage, in Avro format by default, so events can be replayed long after the retention window closes. Log compaction instead retains only the latest event for each unique key. Each option preserves more of the stream. None preserves what a run learned from the stream: the checks, the evidence, and the decisions still live outside the log, if they live anywhere.

What a scheduled agent actually needs between runs

Consider a scheduled automation that wakes on a timer, reads new events from an event hub, and processes them with an AI agent: triaging telemetry, comparing sources, drafting a summary, and noting exceptions. Event Hubs handles the trigger well. Events arrive in order inside their partitions, survive a consumer restart through checkpointing, and can be replayed if a run fails.

The gap appears in the second week, not the first run. The agent needs to know that this site already reported the same fault twice, that a particular sensor feed was wrong last time and had to be corrected by hand, and that a decision made three runs ago changed how this category of event should be handled. None of that lives in a partition. The partition holds the next event. The history of decisions, evidence, and corrections has no offset to sit at, so teams end up rebuilding it from logs, spreadsheets, and re-briefing prompts at the start of every run.

That re-briefing is the hidden cost. Each run pays it in time, tokens, and repeated mistakes, because the agent cannot tell work that is genuinely new from work that only looks new.

Give the runs a memory built for runs

That is the gap Vilix AI fills, alongside the stream rather than instead of it. Event Hubs keeps delivering the trigger. Vilix AI keeps what the runs learned from every trigger before it, as one shared memory every agent and run reads from.

Vilix AI is cloud-hosted with zero infrastructure to run, so there is no second storage system to deploy and maintain next to the namespace. Agents connect over MCP, and the same memory follows them everywhere: the same context is available to a scheduled automation at night, a coding agent in the morning, and a chat session in the afternoon, because the memory lives in one hosted layer rather than inside any single tool.

It also stores the right material. Vilix AI keeps full conversation history, not just extracted facts, so a later run can revisit what was actually said, checked, and decided, in context. Decisions, corrections, and dead ends stay retrievable by meaning, ready at the start of the next run instead of reconstructed under pressure.

Starting takes minutes. There is a free plan that stays free forever, and a 7-day Pro trial with no credit card required. Data stays under the operator's control, with export or delete at any time. The retention window can stay what it was designed to be, days of reliable delivery and replay, while the memory of the work stops expiring with it.

Event Hubs remembers the event, completely, until the clock removes it. Let it do that job. Give the agents consuming from it a memory that keeps the rest: what the last run found, what it decided, and what the next run should do differently because of it.