Does Semantic Kernel Remember Between Sessions? Vilix AI Remembers What the Kernel Forgets
Semantic Kernel keeps the chat in a ChatHistory list inside your process, resent in full on every call. The list dies with the process, so the next session starts blank unless you build persistence, reducers, providers and a store yourself.
AI Stella and Liam are AI hosts with AI-generated voices. About our AI hosts
Key takeaways
- Inside one session, Semantic Kernel keeps only a ChatHistory list in your process memory. Your code appends each message and reply and resends the whole list with every call, unbounded by default, so long sessions grow the prompt and the bill.
- When the session ends, nothing automatic survives: no built in session store and no user profile. You serialize ChatHistory to JSON yourself, keyed by conversation ID, store it, and reload it yourself. The older SemanticTextMemory APIs are legacy.
- The two thread memory providers are both experimental. WhiteboardProvider extracts requirements, proposals, decisions and actions so they survive truncation, and Mem0Provider sends thread messages to Mem0, scoped by user ID across threads or by thread ID inside one thread.
- A production agent needs four pieces you build and operate yourself: persisted history, reducers to bound it, providers on the thread, and your own long term vector store. The framework orchestrates memory; it never operates the storage, and a scheduled run starts as a brand new session with empty provider inputs.
- Vilix AI fixes the gap: get_context at session start loads the full history for that user and project, and save_turn at the end saves the exchange with a source label, failures included, newest wins, shared over MCP with every tool, cloud hosted with zero infrastructure.
Show notes
Your Semantic Kernel agent holds the whole chat in a ChatHistory list inside your process, then the process ends and the next session greets the same user like a total stranger. In this episode of Agentic Pod, Liam and Stella break down what Semantic Kernel actually keeps: ChatHistory resent in full on every call, reducers that truncate or summarize, experimental WhiteboardProvider and Mem0Provider memory on an AgentThread, and the four pieces you have to build yourself for anything to survive. Vilix AI is the memory outside the framework: get_context at session start loads the full history, and save_turn at the end saves the exchange for the next session in any tool.
What we cover:
- What Semantic Kernel keeps in one session: a ChatHistory list in process memory, appended by your code and resent in full with every call, unbounded by default
- Reducers: truncate or summarize old turns so a long session does not blow the context window or the token bill
- What happens when the session ends: no built in session store and no user profile, so you serialize ChatHistory to JSON yourself, keyed by conversation ID, and reload it yourself
- The memory providers: WhiteboardProvider extracts requirements, proposals, decisions and actions so they survive truncation, and Mem0Provider sends thread messages to Mem0 with user ID or thread ID scope, both experimental
- The four piece build: persist the history, bound it with reducers, attach the providers, and wire your own long term vector store, because the framework orchestrates memory but never operates the storage
- How Vilix AI fixes each pain: get_context at session start, save_turn at the end with source labels, full conversation history over MCP, projects, project rules, user rules, skills and the agent inbox, cloud hosted with zero infrastructure, export or delete anytime, free forever plan
Chapters
Questions answered in this episode
Does Semantic Kernel remember between sessions?
No, not by itself. Inside one session, Semantic Kernel keeps the conversation in a ChatHistory object that lives in your process. When the session ends, that object is gone unless your code saved it somewhere. Nothing is retained across sessions by default; the persistence layer is always yours to build.
What do the WhiteboardProvider and Mem0Provider actually store?
The WhiteboardProvider extracts requirements, proposals, decisions, and actions from thread messages onto a whiteboard that travels with the thread, mainly so distilled context survives truncation. The Mem0Provider sends thread messages to the Mem0 service, which extracts memories, and queries them back per request, scoped by user ID across threads or by thread ID inside one thread. Both are experimental, and in both cases the memory lives outside Semantic Kernel.
Why does my scheduled Semantic Kernel agent forget everything overnight?
Because a scheduled run is a brand new session every time. Its ChatHistory starts empty, and the memory providers' inputs start empty too, unless your code persisted history keyed to something stable and reloads it at the start of the run.
How does Vilix AI help a Semantic Kernel agent?
get_context at session start loads the full history that matters, the exchange and the reasoning, not just final results. save_turn at the end saves the new exchange with a source label, failures included, newest wins, shared over MCP with every tool, so the next session in any tool starts where the last one left off.
Links & resources
Full transcript
Intro
Hey hey hey, welcome to Agentic Pod! I'm Liam.
And I'm Stella! Your Semantic Kernel agent nailed the chat yesterday. Every detail.
It did. ChatHistory held every turn. The model saw the whole list.
So this morning the same agent greets the same user like an old friend?
Like a total stranger. New process, empty list, zero memory of yesterday.
Nothing at all?
Nothing. The history lived in that process, and the process ended. Vilix AI is how that agent starts today where yesterday stopped.
What Semantic Kernel keeps in one session
Start fair. Inside one session, what does it keep?
One object. ChatHistory. A list in your process memory.
And remembering means what, mechanically?
Your code appends each message and each reply to that list.
Then resends the whole list with the next call?
Every call. The model rereads the whole list each time.
So a long session keeps growing the prompt?
Unbounded by default. Bigger prompt, bigger bill, every turn.
The fix inside the framework?
Reducers. Truncate old messages, or summarize them to fit.
And where does that list physically live?
In your server memory. Restart, scale out, close the app, and it is gone.
Gone as in never stored anywhere durable?
Never stored anywhere. So what survives the session ending?
What happens when the session ends
Short answer. Nothing automatic. No session store.
No user profile that builds up over time?
None. Nothing the agent learned about the user carries over.
So the returning user from the intro gets what?
A blank ChatHistory and a polite hello. From an agent that met them yesterday.
Unless my code saved it first?
You serialize ChatHistory to JSON yourself, keyed by conversation ID.
Database or cache. Reload it when they come back.
The framework hands you the object. Saving and loading are your code.
What about the older memory APIs? SemanticTextMemory?
Legacy now. New code should avoid them.
So the modern answer is lower level and more homework.
Chat history short term, vector stores for retrieval, thread providers for extracted memories. Vilix AI covers the long term part. We will get to how.
Hold on. Those providers sound like real memory. What do they do?
The providers and the four piece build
Two providers, both experimental. They attach to an AgentThread.
First one?
WhiteboardProvider. It extracts what mattered from each message.
Requirements, proposals, decisions, actions?
Onto a whiteboard that travels with the thread. Its job is surviving truncation.
You cut the history down, the whiteboard keeps the distilled version.
You cap how many messages it keeps. Weak entries drop first.
Second provider?
Mem0Provider, the long term one. Every thread message goes to Mem0.
Which extracts memories, then queries them back per request?
Scope decides everything. User ID scope follows the user across threads.
Thread ID scope, they stay locked to that one thread.
You can run both together. But notice the pattern.
The memory never lives in Semantic Kernel itself?
Never. It lives in Mem0, in your vector store, in your database. The framework orchestrates the handoff. It never operates the storage.
So production needs four pieces, all mine?
Four. Persist the history. Bound it with reducers. Attach the providers. Wire your own store.
And my scheduled morning agent?
A cron run is a new session every time. The providers start empty too.
Every Semantic Kernel team becomes a memory team.
Every single one. What if the memory lives outside the framework entirely?
The Vilix AI fix and the verdict
Step one. At session start, the agent calls get_context in Vilix AI.
What loads?
The history for that user and project. Full conversation history in Vilix AI, not a summary.
The decisions, the corrections, the reason a choice went one way?
All of it. Semantic search plus keyword matching, so exact order IDs and policy names come back literally.
Step two?
Before the session ends, save_turn in Vilix AI, with a source label for that agent and run.
So tomorrow starts with today's full exchange in view.
Failures save in Vilix AI too, so the next session skips the broken path. When records disagree, the newest save wins.
My other tools see the same memory?
Same Vilix AI memory over MCP. Your kernel agent, ChatGPT, Claude, Cursor, every tool.
Standing rules and repeat workflows?
Projects, project rules and user rules live in Vilix AI. Workflows become skills. The agent inbox passes notes between agents.
Do I run a store for any of that?
No. Vilix AI is cloud hosted, zero infrastructure. One API key connects the agent.
Control over the data?
Export or delete everything in Vilix AI anytime. Vilix AI is free forever, with a 7 day Pro trial, no credit card.
My verdict: Semantic Kernel runs the agent. Vilix AI remembers the user.
Same. ChatHistory holds the chat, providers hold the notes, Vilix AI holds the story. Blog and guide are linked below. Does your agent remember yesterday? Tell us below. See you next time!