Does Amazon EventBridge Remember Between Runs? Rules Route the Event and Move On. The Next Run Still Starts With Only Its Event.

Amazon EventBridge remembers an event only while it is routing it, unless an archive has been set up in advance. An event bus receives an event, matches it against rules, and sends a copy to every target those rules select. Once delivery succeeds, the bus holds nothing a later run can read. An archive changes the storage part: it can keep matched events for a set number of days, or indefinitely by default, and a replay can send those events onto the bus again. Even then, the archive holds the original event exactly as it arrived. What a run checked, decided, and finished after receiving that event was never stored by EventBridge, so the next run starts with an event, and nothing else.

A bus matches, delivers, and moves on

The core of EventBridge is routing based on content. A producer puts an event on a bus as a JSON object with a source, a detail type, and a detail payload. Rules on that bus compare the event against event patterns. A pattern can match a source, a detail field, a value range, or a combination of fields. Every rule that matches sends the event to its targets, which can be a Lambda function, an SQS queue, an SNS topic, a Step Functions execution, an API destination, or another bus.

That matching is powerful because the decision is made from the event itself, not from a fixed subscription list alone. A single order event can reach a billing target because its amount field crosses a threshold, and a reporting target because its region field matches, without the producer knowing either target exists.

Delivery is retried when a target fails. EventBridge retries failed deliveries for up to 24 hours by default, and a rule can be configured with a dead-letter queue so an event that exhausts its retries is sidelined to SQS instead of being dropped. Those retries are about reaching the target once. They are not a history service. A target cannot ask the bus what arrived yesterday, what another target did with the same event, or whether a similar event was already handled last week. When the routing and the retries end, the bus has moved on.

An archive keeps the event, not the work

An archive is an optional store attached to a bus. It can collect all events on the bus, or only events that match a pattern set on the archive itself. The owner chooses a retention period in days, and if no period is chosen, EventBridge stores archived events indefinitely by default. Events stay in the archive until they pass that retention period or the archive is deleted.

A replay takes a time range from an archive and re-emits those events onto the bus, either to all rules or to a specific rule. Replaying does not remove events from the archive, so the same range can be replayed again later. Replayed events carry a replay name so targets can tell them apart from live events, and EventBridge deletes replay records themselves after 90 days.

Used well, an archive solves a real recovery problem. A target that was broken for an afternoon can receive that afternoon again. A new target can be backfilled with events that arrived before it existed. An audit can be answered from stored events instead of reconstructed logs.

None of that makes the archive a record of work. The stored event is unchanged by processing. It does not gain a note saying which run handled it, what that run looked up, what conclusion it reached, or whether the action it triggered succeeded. A replay therefore hands a target the starting point again, not the ending point. The target still has to work out, from somewhere else, what already happened the first time.

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

Consider a scheduled automation that receives events through EventBridge and acts on them across n8n, Make, or a custom agent. At the start of a new run, the delivered event is only one part of what that run needs. It also needs to know which similar events were already investigated, so a replayed or redelivered event does not trigger the same work twice. It needs the decisions made on earlier events, so a pattern that was checked and cleared yesterday is not treated as brand new today. It needs the full reasoning behind those decisions, so a genuinely new event that looks similar can be separated from a settled one. And it needs that record to be shared, so a second workflow reading the same stream starts from the same past.

EventBridge supplies the event and, when configured, a replayable copy of the event. 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 bus, archive, or database to provision beside the existing setup. The same memory is available everywhere over MCP, so the automation receiving the event, 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 routed event or a short summary.

The practical split is simple. Let EventBridge do the job it is built for: matching events to rules, delivering to targets, retrying failures, and archiving events when that feature is turned on. 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 replayed event then meets an agent that can check the record 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. EventBridge will route the next event and, with an archive, keep a copy of it for replay. The memory makes sure the next run arrives knowing everything the earlier runs learned.