Your Google ADK Agent Remembers the Chat. Your Scheduled Runs Still Wake Up Blind.

Google's Agent Development Kit comes with sessions, state, and a long-term memory service built right into the framework. That is genuinely better than most agent frameworks ship with. So here is the surprise that bites automation teams anyway: when your ADK agent runs on a schedule, every single run wakes up blind. It remembers the conversation it is in. It has no idea about the one it had yesterday.

If you run ADK agents on Cloud Scheduler, Cloud Run, or any cron-style trigger, this is the gap you need to understand before you build your automation stack on it.

What ADK actually remembers, out of the box

ADK splits memory into two very different primitives, and confusing them is the source of most of the pain.

Session and state are short-term memory for one ongoing conversation. A session tracks the history of events (every turn, every tool call) and holds temporary key-value state for the task at hand. It lives for exactly one conversation, and when the session ends, the state is cleared. Where sessions persist depends on which SessionService you choose: InMemorySessionService for local dev, DatabaseSessionService backed by SQLite or Postgres for production, or VertexAiSessionService when you deploy on Vertex AI Agent Engine. A durable SessionService means yesterday's session still exists on disk or in the database. It does not mean today's agent can see it.

MemoryService is the long-term knowledge store. It is a searchable archive that spans many past sessions. The framework defines the interface and four operations: ingest a completed session into memory, ingest events incrementally, write memory items directly, and search memory by semantic query. ADK ships only the interface; the storage backend is yours to provide, from an in-memory implementation to a vector database.

So the honest answer to "does Google ADK remember between sessions" is: it gives you the plumbing to remember across sessions, but nothing is automatic. An ADK agent does not carry context from one session to the next unless you built the bridge.

Where scheduled runs break the illusion

In a chat product, this is manageable. The user keeps one session open, you reuse the session ID, and the conversation flows. Memory is a nice-to-have upgrade.

In automation, the trigger creates a new session every run. A scheduled routine fires, your runner starts a fresh session, the agent does its job, the session ends. Next run: another fresh session. The agent never sees the same session twice, which means:

• It does not know what it already did last run, so a nightly triage agent can re-flag the same items or re-escalate the same incidents.
• It does not know what it learned last run, so the workaround it discovered on Tuesday gets rediscovered, painfully, on Wednesday.
• It does not know what changed since last run, so every execution re-derives context it already computed, burning tokens and time.

Each of these has a fix inside ADK's primitives. You can call add_session_to_memory when a run completes to ingest what happened. You can wire search_memory or the load_memory and preload tools so the next run retrieves relevant snippets before it starts. If you deploy on Agent Engine, the managed Memory Bank option handles cross-session recall with automatic extraction. These all work. They are all also wiring you have to build, operate, and debug yourself, per agent, forever.

That is the gap: ADK remembers sessions beautifully and gives you the parts for cross-session memory, but a scheduled agent that wakes up already briefed is not the default. The default is a fresh session with amnesia.

The question to ask about any memory option

When you evaluate how to close this gap, ask one question: does the memory survive outside the framework's own session lifecycle, and does anything else in my stack get to read it?

Session state dies with the session by design. A database-backed SessionService preserves the record, but it is still keyed to one conversation. MemoryService backends persist across sessions, but they live inside your ADK deployment. If your scheduled triage agent, your Slack-facing agent, and the Claude Code session where you debug the automation are three separate systems, the context each one learns stays trapped in its own store.

Automation stacks are rarely one tool. A scheduled agent on ADK feeds a dashboard in another tool, gets debugged in an IDE agent, and hands off to a chat agent in production. Each of those starts from zero unless the memory layer sits outside all of them and speaks to all of them.

What a scheduled agent with real memory looks like

The shape of the fix is simple to describe. Every run opens with the agent loading what matters from previous runs: last run's outcomes, open items, decisions that were made, context that was expensive to compute. During the run, it records what it does. When the run ends, that record is saved where the next run, and every other tool in the stack, can find it. No re-briefing, no rediscovery, no duplicated escalations.

You can build this on ADK's primitives, and for a single-agent setup with engineering time to spare, that is a reasonable path. But if you run a real automation stack, building per-agent memory wiring on top of sessions and a self-hosted vector store is exactly the kind of infrastructure that eats quarters. It needs ingestion logic, recall ranking, cross-tool access, and ongoing tuning as your agents multiply.

That is the problem Vilix AI was built to solve. It is a cloud-hosted memory layer your agents read and write over MCP, so there is zero infrastructure to manage. The same memory follows your agent everywhere: your scheduled ADK runs, your chat sessions, your IDE agents, every tool you connect. It stores full conversation history, not just extracted facts, so an agent can revisit exactly what happened instead of trusting a summary. There is a free plan forever, a 7-day Pro trial that asks for no credit card, and you can export or delete everything at any time. Your agents wake up with the context of every run that came before, and it works the same way on Monday as it does on day one hundred.

The bottom line

Google ADK's session model is excellent at remembering one conversation, and its MemoryService gives you the interface for remembering across them. What it does not give you, by default, is a scheduled agent that wakes up knowing what happened in every previous run. That part is still your job.

Before you build it yourself, count the cost of building it for every agent, on every schedule, across every tool in your stack. Then ask whether a shared memory layer that does it once would be a better foundation. You can try it here: https://vilix.ai/?utm_source=vilix-blog&utm_medium=article&utm_campaign=google-adk-remembers-the-chat-scheduled-runs-still-start-blind