# EP 51: Does a Slack AI Agent Remember Between Runs? Vilix AI Remembers the Channel, Not Just the Thread

- URL: https://www.agenticpod.net/episodes/ep51-slack-ai-agent-memory/
- Watch on YouTube: https://www.youtube.com/watch?v=eVNzhaX3v-I
- Published: 2026-11-18
- Length: 5 min
- Hosts: Stella (asks), Liam (answers). Both are AI hosts with AI-generated voices.

## Summary

Your Slack AI agent is brilliant inside one thread and blank in the next one: a custom agent reads only the thread it was summoned in, so a new thread starts blank and old decisions get invented.

## Key takeaways

- Slack AI search is retrieval over stored messages, channels, files and canvases, not memory of what the agent did or decided. The agent itself keeps nothing, and a custom agent reads only the thread it was summoned in.
- A new thread or DM starts blank: the 7 AM digest cannot say which tickets are still open, and the on-call agent never saw the first incident's fix, because both live in other threads.
- The worst failure is the invented answer: an agent that cannot remember a decision invents one, with full confidence, inside a thread the team trusts.
- Search is not memory: retrieval waits for the right question, while memory carries context forward on its own. The DIY fix turns your memory into a second codebase with its own schema and failure modes.
- Vilix AI fixes the gap: get_context at thread start loads the decision and its reasoning, and save_turn at the end saves the thread with a source label, failures included, newest wins, over MCP with zero infrastructure.

## Chapters

- 0:00 Intro
- 0:43 What Slack search actually gives you
- 1:26 The thread boundary in production
- 2:35 Search is not memory
- 3:30 The Vilix AI fix and the verdict

## FAQ

**Does a Slack AI agent remember between runs?**

Inside one thread, yes: the thread is its working memory. A new thread, a new DM, or a scheduled run in a fresh thread starts blank. Slack AI search can retrieve stored messages, but that is retrieval over what people wrote, not memory of what the agent did or decided.

**What does Slack AI search actually give an agent?**

Search over the messages Slack stores, plus files and canvases, inside what the user is allowed to see. It answers when you ask the right question. It does not carry context forward on its own, and it holds nothing about the agent's own past decisions, open items, or failures.

**Why does a Slack agent invent answers?**

When an agent cannot remember a decision, it often fills the gap with a plausible one, stated with full confidence. The fix is a real record the agent reads first: the decision and its reasoning, saved where the next thread can load it.

**How does Vilix AI help a Slack agent?**

The agent calls get_context at thread start to load the full history that matters, then save_turn at the end to save the thread with a source label, shared over MCP with every tool, so the next thread, the digest, and the on-call agent read the record first instead of starting blank.

## Resources

- [Vilix AI, one shared memory for ChatGPT, Claude, Claude Code, Codex, Cursor, OpenClaw, Hermes and every MCP tool](https://vilix.ai)
- [Connect Vilix AI in under two minutes per tool](https://vilix.ai/get-started)
- [Read the full post](https://vilix.ai/blog/slack-ai-agent-remembers-the-thread-not-the-channel/)
- [Technical guide with commands and prompts](https://github.com/asly-97/ai-automation-workflows/tree/main/slack-ai-agent-memory)

## Transcript

### Intro

Liam: Hey hey hey, welcome to Agentic Pod! I'm Liam.

Stella: And I'm Stella! Picture this. Your Slack agent nails a support thread.

Liam: It reads every reply. It cites the fix from Tuesday. Brilliant.

Stella: Then you open a new thread. What did we decide about the Acme refund last week?

Liam: Silence. Then a confident answer your team never made.

Stella: It invented a refund decision?

Liam: Word for word, with total confidence. The thread ended, so the memory ended. Vilix AI is how the agent remembers the whole channel.

### What Slack search actually gives you

Stella: Start fair. Slack AI itself can search months of chat, right?

Liam: Right. In early 2026, Slack rebuilt Slackbot as a context aware agent.

Stella: It pulls from your channels, your files, your canvases.

Liam: And it drafts briefings in your voice, inside what you are allowed to see.

Stella: That sounds like memory.

Liam: It is retrieval. Slack stores the messages, so the agent can search them.

Stella: Like me with the search bar, just faster.

Liam: Exactly. The agent itself keeps nothing. Not what it did. Not what it decided.

Stella: Close the chat, open a new one, and it starts from search alone.

Liam: And a custom agent you build yourself gets even less. So what does it actually see?

### The thread boundary in production

Liam: A custom Slack agent reads the thread it was summoned in. That thread is its whole working memory.

Stella: Great at summarize this thread.

Liam: Useless at what did the last three Acme threads say. A new thread is a blank slate.

Stella: A DM about another topic?

Liam: Blank there too. Now watch the daily burns. The digest agent runs at 7 AM.

Stella: Summarizing overnight tickets in a fresh thread.

Liam: Yesterday's digest is not in its memory. It cannot say which tickets are still open.

Stella: The on-call assistant next. A second incident, same service, two days later.

Liam: It has no idea what fixed the first one. The weird database flag, the runbook step, all in another thread.

Stella: Which is to say, nowhere.

Liam: Nowhere with great formatting. And the worst failure is the invented answer.

Stella: The Acme refund that never happened.

Liam: An agent that cannot remember a decision often invents one instead. Same confidence, wrong facts, inside a thread your team trusts. Vilix AI closes that gap, and we will get to how.

Stella: Hold on. Why can search not just fix all of this?

### Search is not memory

Liam: Because retrieval waits for the right question. Memory carries the context forward on its own.

Stella: Give me the test.

Liam: An agent with memory checks its own state before it answers.

Stella: It spots the customer who complained twice.

Liam: It follows up on the task it promised yesterday. Search never volunteers any of that.

Stella: So builders wire it up themselves?

Liam: They can. Write every decision into a database at the end of each run. Read it back at the start of the next.

Stella: That works, no?

Liam: It works. And now your memory is a second codebase. Schema, versioning, failure modes, maintained forever.

Stella: Every agent team becomes a database team.

Liam: Every single one. Which raises the real question. What if the memory layer already exists?

### The Vilix AI fix and the verdict

Liam: Step one. At thread start, the agent calls get_context in Vilix AI.

Stella: What loads?

Liam: The full history that matters. The Acme decision, with the reasoning behind it. Full conversations in Vilix AI, not just facts.

Stella: Step two, at the end?

Liam: It calls save_turn in Vilix AI, with a source label for that Slack thread and that run.

Stella: So the digest at 7 AM reads yesterday's record first.

Liam: Exactly. Open tickets carry over. The on-call agent reads the first incident's fix. Failures save in Vilix AI too, so the next run skips the broken path.

Stella: And when two records disagree?

Liam: Newest save wins in Vilix AI. Standing rules live as projects, project rules, and user rules. Repeat workflows live as skills.

Stella: My other tools, Claude Code, Cursor, my phone?

Liam: Same Vilix AI memory over MCP. One memory under the Slack bot, the scheduled runs, and every tool you open. The agent inbox passes notes between agents.

Stella: Do I run servers for that?

Liam: No. Vilix AI is cloud hosted, zero infrastructure. Agencies give each client one Vilix AI account, so client memory stays apart.

Stella: Cost to try it?

Liam: Vilix AI is free forever, with a 7 day Pro trial, no credit card. Export or delete everything anytime.

Stella: My verdict: the thread is a room. Your agent needs the whole building.

Liam: Same. Keep Slack for the conversation. Let Vilix AI carry the channel memory between threads. Blog and guide are linked below. Does your Slack agent remember the last thread? Tell us below. See you next time!
