---
title: "Google's context engineering whitepaper: sessions and memory"
description: "Google's November 2025 whitepaper splits context engineering into sessions, the desk for one conversation, and memory, the filing cabinet across conversations."
image: "https://bombos.ai/assets/og-en-v2.png"
---

# What is Google's context engineering whitepaper on sessions and memory?

Short answer

"Context Engineering: Sessions, Memory" is a 72-page Google whitepaper from November 2025 by Kimberly Milam and Antonio Gulli, published on Kaggle for the 5-Day AI Agents Intensive. It defines context engineering as dynamically assembling and managing what goes into an LLM's context window, and splits the work into sessions (one conversation) and memory (what persists across conversations).

*Piet Baudoin · published November 17, 2026 · November 17, 2026*

## What the whitepaper covers

The paper starts from one fact: LLMs are stateless. Outside their training data they only know what is in the context window of a single call. To build an agent that remembers and personalizes, you have to rebuild that context on every turn. Google calls this dynamic assembly context engineering, and contrasts it with prompt engineering, which focuses on crafting “often static” system instructions. Its own image is mise en place: the chef needs the right ingredients ready, not just the recipe. The stated goal is that the model has “no more and no less than the most relevant information”.

The payload it describes has three groups:

| Group | What is in it |
| --- | --- |
| Context to guide reasoning | System instructions, tool definitions, few-shot examples |
| Evidential and factual data | Long-term memory, external knowledge via RAG, tool outputs, sub-agent outputs, artifacts |
| Immediate conversational information | Conversation history, state and scratchpad, the user’s prompt |

## The loop on every turn

The whitepaper describes context management as a cycle that runs each turn:

1.  **Fetch context.** Retrieve user memories, RAG documents and recent conversation events, based on the query.
2.  **Prepare context.** Build the full prompt. This is a blocking “hot-path” step; the agent cannot continue until it is done.
3.  **Invoke the LLM and tools.** Loop until there is a final response, appending tool and model output.
4.  **Upload context.** Write new information to persistent storage, often in the background, so memory consolidation does not slow the reply.

## Sessions: the desk

A session is the container for one conversation: the chronological history plus the agent’s working state. Google’s image is a workbench covered in notes and tools for one project. Long sessions cost tokens and latency, so the paper walks through compaction options such as keeping the last N turns, token-based truncation and recursive summarization, ideally run in the background.

For multi-agent systems it names two patterns: a shared, unified history that every agent writes to, or separate histories where agents only exchange final outputs, through agent-as-a-tool or the A2A protocol. It also flags a real limit: session storage is tied to a framework’s own objects, so an agent built with LangGraph cannot natively read sessions stored by an ADK agent.

## Memory: the filing cabinet

When the project is finished, you do not shove the messy desk into storage. You file only the finished documents. That is memory, and the paper treats it as an LLM-driven process with two steps: **extraction** (what in this conversation is worth keeping) and **consolidation** (merge duplicates, resolve contradictions with what is already stored). Other design choices it covers:

1.  **Type.** Declarative memory (“knowing what”) and procedural memory (“knowing how”). Most tools today handle the declarative kind.
2.  **Scope.** User-level (most common), session-level (a compact record of one long conversation) and application-level, shared by all users, which must be sanitized so nothing leaks between users.
3.  **Provenance.** Track where each memory came from. Data from a form is high trust, something inferred from chat is lower, and corroboration from several sources raises confidence.
4.  **Triggering.** Generate memories at a set cadence (every turn, end of session) or let the agent decide, which the paper calls memory-as-a-tool.
5.  **Retrieval timing.** Load memories at the start of every turn, or let the agent fetch them when needed.

Google’s Agent Development Kit makes this split concrete. A session and its state are short-term memory for one chat; a MemoryService holds long-term knowledge that can be searched across sessions. The basic `InMemoryMemoryService` needs no setup but loses everything on restart and matches on keywords, so it suits prototypes. `VertexAiMemoryBankService` is the managed option: it extracts information from conversations, consolidates it with existing memories using an LLM and offers semantic search. The `load_memory` tool lets the agent decide when to search, `preload_memory` retrieves at the start of every turn, and neither saves anything; storing is a separate step, such as `add_session_to_memory` for a whole session or `add_memory` for an explicit item.

## The common misunderstanding

Many readers take this as “memory is RAG over chat logs”. The whitepaper explicitly says otherwise. Its comparison table puts RAG on static, shared, authoritative documents written in batch, and memory on dynamic, per-user facts that are extracted from dialogue, consolidated over time and carry inherent uncertainty. The hard part of memory is not the search; it is deciding what to keep, what to overwrite and how much to trust it. For the retrieval side, see [Is RAG the same as AI memory?](https://bombos.ai/en/questions/ai-memory/rag-vs-ai-memory/)

## What this means for a team

The paper’s default is per-user memory, for good reason in consumer apps. A team is a different case. Much of what a team needs, such as “the codename XYZ refers to this project” or how quotes are written, is exactly what the paper files under application-level and procedural memory, and it is the least developed part of most tools. If each person’s assistant only builds user-level memory, colleagues keep explaining the same things to their own AI. Google’s ADK team makes a related point in its December 2025 engineering post: memory should be “searchable (not permanently pinned)” and retrieval should be agent-directed. For the hands-on product, see [What is Vertex AI Memory Bank?](https://bombos.ai/en/questions/ai-memory/what-is-vertex-ai-memory-bank/) and for team setup [How do you set up context engineering for a team?](https://bombos.ai/en/questions/context-engineering/how-to-set-up-context-engineering-for-a-team/)

## Where Bombos fits

The whitepaper’s application-level and procedural memory is what Bombos is built around: one shared memory of team knowledge and learned rules, loaded into whichever AI tool someone uses, from Claude and ChatGPT to Copilot, Cursor and your own agents. In the spirit of the paper’s advice on provenance, you can see what each answer rests on. It runs in our cloud or on your own server, and one person can try it first for their own agents.

## Related questions

Where can I read Google's context engineering whitepaper?

Kaggle hosts it as "Context Engineering: Sessions & Memory". It was written for day 3 of the Google and Kaggle 5-Day AI Agents Intensive in November 2025.

Is the whitepaper only about Google products?

No. Most of it is framework-neutral: the context loop, session patterns, memory scope, extraction and consolidation, provenance. Its code examples use Google's ADK and Agent Engine Memory Bank, and it names Mem0 and Zep as other memory managers.

How does the whitepaper define memory versus RAG?

RAG makes an agent "an expert on facts", memory makes it "an expert on the user". RAG reads a static, shared knowledge base; memory is extracted from conversations, usually scoped per user, and carries some uncertainty.

What does the whitepaper say about security?

Redact personal data before session data is persisted, sanitize application-level memories so nothing leaks between users, and validate information before it enters long-term memory to guard against memory poisoning.

## Sources

1.  [Context Engineering: Sessions & Memory (Google whitepaper on Kaggle, November 2025)](https://www.kaggle.com/whitepaper-context-engineering-sessions-and-memory)
2.  [Architecting efficient context-aware multi-agent framework for production (Google Developers Blog, December 2025)](https://developers.googleblog.com/architecting-efficient-context-aware-multi-agent-framework-for-production/)
3.  [ADK documentation: Memory (Google Agent Development Kit)](https://adk.dev/sessions/memory/)

## What does your AI forget?

1.  01You tell us which AI you use and where it keeps starting over.
2.  02We show what a shared memory changes there, on your own examples.
3.  03You keep the plan, with or without Bombos.

![Piet Baudoin](https://bombos.ai/assets/team/piet-klein.jpg)

**Piet Baudoin**You talk to Piet, from the Bombos teamDutch team from Utrecht and Nijmegen · data in Europe

## More questions about Context engineering

-   [What is Context Engineering 2.0?](https://bombos.ai/en/questions/context-engineering/what-is-context-engineering-2-0/)
-   [How does LangChain approach context engineering?](https://bombos.ai/en/questions/context-engineering/how-does-langchain-approach-context-engineering/)
-   [What is agentic context engineering (ACE)?](https://bombos.ai/en/questions/context-engineering/what-is-agentic-context-engineering/)
-   [What is advanced context engineering for coding agents?](https://bombos.ai/en/questions/context-engineering/advanced-context-engineering-for-coding-agents/)
-   [How do you do context engineering for multi-agent systems?](https://bombos.ai/en/questions/context-engineering/context-engineering-for-multi-agent-systems/)
-   [What is harness engineering, and how does it differ from prompt and context engineering?](https://bombos.ai/en/questions/context-engineering/what-is-harness-engineering/)
-   [What is the context engineering skill for Claude, and how do you install it?](https://bombos.ai/en/questions/context-engineering/what-is-the-context-engineering-skill/)
-   [What is the difference between context engineering and prompt engineering?](https://bombos.ai/en/questions/context-engineering/context-engineering-vs-prompt-engineering/)

[All questions about Context engineering →](https://bombos.ai/en/questions/context-engineering/)


---

```json
{"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://bombos.ai/#organization","name":"Bombos","url":"https://bombos.ai/","logo":"https://bombos.ai/assets/bombos-bee.png","description":"Bombos is the memory layer under every AI your team uses. One shared memory for Claude, ChatGPT, Copilot, Cursor and your own agents, that learns how you work.","sameAs":["https://www.linkedin.com/company/bombos-ai","https://www.youtube.com/@truebombos","https://www.instagram.com/truebombos/","https://bsky.app/profile/bombostrue.bsky.social","https://www.threads.com/@truebombos","https://mastodon.social/@Bombos","https://www.tiktok.com/@truebombos","https://t.me/truebombos","https://www.pinterest.com/truebombos/","https://github.com/bombos-ai","https://linktr.ee/bombos.ai","https://bombosai.substack.com","https://hashnode.com/@bombosai","https://hackernoon.com/u/bombos","https://dev.to/bombos"],"email":"info@bombos.ai","areaServed":["NL","Europe"],"knowsLanguage":["nl","en"],"contactPoint":{"@type":"ContactPoint","email":"info@bombos.ai","contactType":"sales","url":"https://bombos.ai/en/contact/","availableLanguage":["nl","en"]}},{"@type":"WebSite","@id":"https://bombos.ai/#website","name":"Bombos","url":"https://bombos.ai/","inLanguage":["nl-NL","en"],"publisher":{"@id":"https://bombos.ai/#organization"}}]}

{"@context":"https://schema.org","@type":"Article","headline":"What is Google's context engineering whitepaper on sessions and memory?","description":"Google's November 2025 whitepaper splits context engineering into sessions, the desk for one conversation, and memory, the filing cabinet across conversations.","abstract":"\"Context Engineering: Sessions, Memory\" is a 72-page Google whitepaper from November 2025 by Kimberly Milam and Antonio Gulli, published on Kaggle for the 5-Day AI Agents Intensive. It defines context engineering as dynamically assembling and managing what goes into an LLM's context window, and splits the work into sessions (one conversation) and memory (what persists across conversations).","datePublished":"2026-11-17T00:00:00.000Z","dateModified":"2026-11-17T00:00:00.000Z","author":{"@type":"Person","name":"Piet Baudoin"},"publisher":{"@type":"Organization","@id":"https://bombos.ai/#organization","name":"Bombos","logo":{"@type":"ImageObject","url":"https://bombos.ai/assets/bombos-bee.png"}},"image":"https://bombos.ai/assets/og-en-v2.png","mainEntityOfPage":"https://bombos.ai/en/questions/context-engineering/what-is-googles-context-engineering-whitepaper/","inLanguage":"en-US","isPartOf":{"@type":"CollectionPage","name":"Context engineering","url":"https://bombos.ai/en/questions/context-engineering/"},"citation":[{"@type":"CreativeWork","name":"Context Engineering: Sessions & Memory (Google whitepaper on Kaggle, November 2025)","url":"https://www.kaggle.com/whitepaper-context-engineering-sessions-and-memory"},{"@type":"CreativeWork","name":"Architecting efficient context-aware multi-agent framework for production (Google Developers Blog, December 2025)","url":"https://developers.googleblog.com/architecting-efficient-context-aware-multi-agent-framework-for-production/"},{"@type":"CreativeWork","name":"ADK documentation: Memory (Google Agent Development Kit)","url":"https://adk.dev/sessions/memory/"}]}

{"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Bombos","item":"https://bombos.ai/en/"},{"@type":"ListItem","position":2,"name":"Questions","item":"https://bombos.ai/en/questions/"},{"@type":"ListItem","position":3,"name":"Context engineering","item":"https://bombos.ai/en/questions/context-engineering/"},{"@type":"ListItem","position":4,"name":"What is Google's context engineering whitepaper on sessions and memory?","item":"https://bombos.ai/en/questions/context-engineering/what-is-googles-context-engineering-whitepaper/"}]}

{"@context":"https://schema.org","@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Where can I read Google's context engineering whitepaper?","acceptedAnswer":{"@type":"Answer","text":"Kaggle hosts it as \"Context Engineering: Sessions & Memory\". It was written for day 3 of the Google and Kaggle 5-Day AI Agents Intensive in November 2025."}},{"@type":"Question","name":"Is the whitepaper only about Google products?","acceptedAnswer":{"@type":"Answer","text":"No. Most of it is framework-neutral: the context loop, session patterns, memory scope, extraction and consolidation, provenance. Its code examples use Google's ADK and Agent Engine Memory Bank, and it names Mem0 and Zep as other memory managers."}},{"@type":"Question","name":"How does the whitepaper define memory versus RAG?","acceptedAnswer":{"@type":"Answer","text":"RAG makes an agent \"an expert on facts\", memory makes it \"an expert on the user\". RAG reads a static, shared knowledge base; memory is extracted from conversations, usually scoped per user, and carries some uncertainty."}},{"@type":"Question","name":"What does the whitepaper say about security?","acceptedAnswer":{"@type":"Answer","text":"Redact personal data before session data is persisted, sanitize application-level memories so nothing leaks between users, and validate information before it enters long-term memory to guard against memory poisoning."}}]}
```
