Does Google Cloud Tasks Remember Between Runs? A Task Lives for Up to 31 Days. The Next Run Still Starts With Only Its Payload.

Google Cloud Tasks remembers the task, exactly as it was created, until the task is done or too old. A task sits in its queue with its payload, its target, and its schedule, and it stays there through retries until it succeeds, exhausts its attempts, or reaches 31 days of age. That is dependable delivery memory. What Cloud Tasks never keeps is anything the handler learned while doing the work. The next run still starts with only its payload.

A queue holds tasks, not outcomes

Cloud Tasks is a managed dispatch service. Producers create tasks in a queue, and the service delivers each task to its target: an HTTP endpoint, an App Engine handler, or a Cloud Run service, at the rate and schedule the queue allows. A task can be scheduled up to 30 days ahead, and once created, a task cannot be updated. The payload fixed at creation is the payload every attempt receives.

That immutability is the first clue about what kind of memory a queue has. The queue remembers an instruction perfectly. It does not remember a result. When a handler finishes, it answers with an HTTP status code. A success code in the 200 range tells Cloud Tasks the work is done, and the task is deleted. The handler's response body, its findings, and its decisions are not stored in the queue, attached to any record, or offered to any later task. The most successful run leaves the least behind: a deleted task.

Retries repeat the same task, they do not continue it

When a handler returns an error, Cloud Tasks tries again under the queue's retry configuration. The settings cover how many attempts to make, how long to keep retrying from the first attempt, and how the backoff grows between attempts, doubling at first and then lengthening up to a maximum interval. Attempts can even be set to unlimited, in which case retrying continues until the retention limit ends it.

Every one of those attempts receives the same task. Retry in Cloud Tasks means redelivery, not resumption. If a handler checked four sources, ruled out three explanations, and then failed on the fifth step, the next attempt gets the original payload and starts the checking from the top. The queue knows an attempt failed. It does not know how far the attempt got, what it found on the way, or which parts of the work are already safe to skip.

A naming detail underlines the point. After a task is deleted, its name stays reserved for a while, up to a day in the deduplication window, so the same task cannot be created twice by accident. The system remembers that a task existed, briefly, to prevent a duplicate. It keeps nothing about what the task accomplished.

The clock deletes by age, not by understanding

A task lives for a maximum of 31 days. After a task is 31 days old, it is deleted regardless of whether it was dispatched or not. A task that succeeds is deleted at once, and a task that exhausts its attempts and its retry duration is deleted as well. Nothing graduates into an archive, a history, or a shared state that later work can read.

The size limit tells the same story from the other side. A task can carry at most 100 KB, which is plenty for identifiers, parameters, and a compact instruction set. It is a delivery envelope, sized for telling a handler what to do. It was never sized, or shaped, to hold what a series of runs figured out while doing it: the evidence gathered, the exceptions found, and the judgment calls made along the way.

None of this is a flaw in the service. Cloud Tasks was built to deliver work reliably, at scale, with rate limits that protect the target and retries that survive a bad hour. Delivery and memory are different jobs, and the queue only signed up for the first one.

What a scheduled agent actually needs between runs

Consider a scheduled automation built on Cloud Tasks: a timer enqueues a task, the task wakes an AI agent, and the agent reviews new orders, open tickets, or fresh leads and acts on what it finds. Dispatch is the solved half. The task arrives on schedule, retries if the endpoint is down, and disappears when the handler reports success.

The gap shows up across runs. The agent needs to know that a customer in today's batch already answered yesterday's question, that a supplier's feed produced bad data twice last week, and that a decision made ten runs ago changed the threshold for escalating an order. None of that can ride in the next payload unless someone rebuilds it and writes it in by hand. Left alone, each run reconstructs its briefing from databases, logs, and prompt text, and pays for that reconstruction in time, tokens, and repeated mistakes.

That re-briefing is the hidden cost of a stateless schedule. The queue guarantees the agent will be woken. It says nothing about whether the agent will remember being woken before.

Give the runs a memory built for runs

That is the gap Vilix AI fills, alongside the queue rather than instead of it. Cloud Tasks keeps delivering the wake-up call. Vilix AI keeps what the runs learned from every wake-up 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 queues. 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 queue can stay what it was designed to be, a reliable way to deliver a task within 31 days, while the memory of the work stops being deleted with each task.

Cloud Tasks remembers the task, word for word, until the work is done. Let it do that job. Give the agents answering its tasks 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.