Does Google Cloud Pub/Sub Remember Between Runs? Subscriptions Keep a Message for 7 Days by Default. The Next Run Still Starts With Only That Message.

Google Cloud Pub/Sub remembers a message carefully, and it remembers nothing else. A topic accepts a message, every subscription on that topic gets its own copy, and each copy waits in a backlog until a subscriber pulls it, processes it, and acknowledges it. If the acknowledgment never comes, Pub/Sub delivers the message again. What Pub/Sub never stores is anything the subscriber learned while handling the message. That split, between a messaging service that keeps the work item and a run that keeps no findings, explains why scheduled agents fed by Pub/Sub still repeat finished checks, reopen settled questions, and begin every run with only the next message as their brief.

A subscription backlog is storage for messages, not for results

Retention in Pub/Sub runs on a clock. A subscription keeps unacknowledged messages for seven days by default, measured from the moment each message was published. Inside that window, a subscriber can be offline for days and the backlog is still waiting when it returns. Outside that window, Pub/Sub can discard the message even if no subscriber ever received it. Retention protects delivery. It does not turn the backlog into a record anyone consults later.

Topic-level retention widens the window without changing its purpose. A topic can be configured to retain published messages for between ten minutes and thirty-one days, even after every subscription has acknowledged them. With that setting in place, a subscription can seek back to a timestamp or a snapshot and replay messages it already processed. Replay is genuinely useful after a bad deploy, because the same messages can be delivered again. Notice what replay returns, though: the original messages, byte for byte. It returns no notes about the first attempt, no conclusion the first run reached, and no reason a message was handled the way it was. The past that Pub/Sub can hand back is a stack of inputs, never a stack of outcomes.

Acknowledgment tracks one message, not the work around it

Delivery runs on the acknowledgment deadline, ten seconds by default and configurable up to six hundred seconds. When a subscriber receives a message, that message is leased to it for the deadline. Acknowledge in time and the message leaves that subscription's backlog. Let the deadline expire, or send a negative acknowledgment, and Pub/Sub redelivers the message, by default at least once, so duplicates are a normal part of operation and consumers are expected to handle them.

Follow one scheduled automation through that cycle. An event arrives ordering a check on an account. The subscriber spends several minutes gathering history, comparing records, and reaching a decision, then acknowledges the message. The acknowledgment tells Pub/Sub exactly one thing: this delivery is complete. The decision itself, the records that supported it, and the checks that turned out to be dead ends were never part of the message, so none of them enter Pub/Sub. If the same event is published again tomorrow, or redelivered after a deadline expires, the next run receives the same payload and repeats the same gathering from zero, because the system of record for the last run's thinking does not exist.

Ordering keys, schemas, dead-letter topics, and exactly-once delivery for pull subscriptions all strengthen the same side of the line. They make the message more reliable, better ordered, and easier to govern. A dead-letter topic, which receives a message after a configured number of failed delivery attempts, from five to one hundred, preserves the failing payload for inspection. It preserves nothing about what each attempt discovered. Every one of these features answers a question about the message. None of them answers a question about the previous run.

What the next run actually needs

A scheduled agent consuming from a subscription usually needs four things before it starts. It needs to know which messages were already handled to completion, so a duplicate delivery does not trigger duplicate work. It needs the conclusions earlier runs reached, so a question settled last week stays settled. It needs the reasoning around a decision, so a later run can tell why a step was skipped instead of guessing. And it needs that past to be shared, so another agent working in another tool on related events reads the same history instead of a private fragment.

Pub/Sub supplies none of those four, because none of them are messages waiting for delivery. They are 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: there is no extra store to provision beside the topics and no memory service to operate. The same memory is available everywhere over MCP, so the subscriber doing the work, the chat tool used to review the outcome, and every other connected agent read and write one shared memory rather than separate local notes. Vilix AI also 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 compressed summary.

The division of labor stays clean. Let Pub/Sub do the job it is built for: fanning each message out to every subscription, holding each backlog safely for days, and redelivering until the work is acknowledged. Let the memory layer hold what a subscription was never shaped to hold: the record of finished work, the conclusions, and the reasoning, written by each run as it ends and read by the next run before it begins. A redelivered message then meets an agent that can check that record first, recognize work already done, and skip straight to what is genuinely new.

There is no cost to testing the 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 remains portable throughout: export everything or delete it anytime. Pub/Sub will keep the next message safe until a subscriber is ready for it. The memory makes sure the subscriber arrives ready, carrying every earlier run with it instead of a blank start and a payload.