# EP 31: What Is the Best AI Agent Memory for Make Workflows?

- URL: https://www.agenticpod.net/episodes/ep31-make-workflows-agent-memory/
- Watch on YouTube: https://www.youtube.com/watch?v=nCG3_LPches
- Published: 2026-11-09
- Length: 5 min
- Hosts: Stella (asks), Liam (answers). Both are AI hosts with AI-generated voices.

## Summary

Leave one field blank in Make's AI agent module, the Conversation ID, and every run starts as a brand new agent that knows nothing.

## Key takeaways

- Make scenarios are stateless: leave the Conversation ID field blank and every run starts as a brand new agent that knows nothing.
- Data Stores, knowledge files and Google Sheets each cover simple memory needs, but they stay inside Make and each one is manual to maintain.
- A vector database or Mem0 adds real retrieval, at the cost of operating another system yourself.
- Vilix AI attaches to Make's AI agent as an MCP tool: get_context at the start of a run, save_turn at the end, and the same memory is shared with Claude, Codex and Cursor.
- Agencies give each client their own Vilix AI account, so client memories never mix.

## Chapters

- 0:00 Intro
- 0:36 The blank field problem
- 1:34 The options, from Data Stores to Mem0
- 3:25 Memory that leaves Make
- 4:26 The verdict

## FAQ

**Why does my Make AI agent forget previous runs?**

Make runs are stateless, and the agent module only keeps context when the Conversation ID is set. A blank field means a brand new conversation every run.

**What is the simplest memory option for a Make workflow?**

A stable Conversation ID or a Data Store covers basic cases inside Make. For memory that also reaches your other AI tools, an MCP memory layer like Vilix AI fits better.

**Can Make share memory with Claude or Codex?**

Yes, when the memory lives outside Make. Vilix AI is called as an MCP tool inside the scenario and the same memory is read by Claude, Codex, Cursor and other connected tools.

## 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/best-ai-agent-memory-for-make-workflows)
- [Technical guide with commands and prompts](https://github.com/asly-97/ai-automation-workflows/tree/main/make-agent-memory-options)

## Transcript

### Intro

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

Stella: And I'm Stella! Liam, I built a Make scenario with an AI agent in it. Every run, it acts like we've never met.

Liam: That's by design. Leave one field blank in Make's AI agent module, the Conversation ID, and every run creates a brand new agent. Seven memory options exist for Make, and Vilix AI is the one that leaves Make.

Stella: Seven. Okay, I want to know which one I'm picking before the end.

### The blank field problem

Stella: Start with my pain. Why does my agent forget? It's literally the same scenario.

Liam: Make scenario runs are stateless. Nothing carries over unless you write it down and read it back. And that Conversation ID is the sharp edge. Blank field, blank memory.

Stella: So I give it an ID. Problem solved?

Liam: Mostly, um, inside that thread. Give each customer or ticket a stable ID, and follow-ups remember what was said. But a second scenario, with its own agent, starts from zero again. Even for the same customer.

Liam: Yep, two agents, one customer, zero shared brain. That's the first place Vilix AI helps. Make's agent module accepts MCP tools, MCP being the plug that lets an AI app use outside tools. So you attach Vilix AI as a tool, and the agent calls get_context at the start of a run and save_turn at the end. Every scenario reads and writes the same memory.

Stella: But hold on. What about Make's own stuff? Data Stores, that sounds free.

### The options, from Data Stores to Mem0

Liam: Data Stores are great for small facts. Last processed row, a run counter, a "did I already send this" flag. You write a key, a later module reads that key, even in another run.

Stella: So what's the catch?

Liam: You look things up by exact key. No searching by meaning. And you own the rules: what gets written, what goes stale. And it only lives inside Make.

Stella: Okay, and the knowledge files?

Liam: Those are uploaded documents the agent can search. Perfect for your refund policy or tone guide. But they're frozen. A run can't add to them, so they hold what you knew before, not what the agent learned today.

Stella: And the Google Sheet trick?

Liam: Everyone does, and it works. A row at the end of each run, read the latest row at the start. Humans can open it and check. Just past a few thousand rows it gets slow and fragile.

Stella: I keep hearing about vector databases. Do I need one?

Liam: Only if you recall by meaning. Like "find the support answer most like this ticket." Teams wire Pinecone or Qdrant in with HTTP modules. But you run embeddings, chunking, tuning, and each recall costs you Make operations.

Stella: So two stores. One exact, one fuzzy.

Liam: Often, yeah. Then there's Mem0, the open source one. Its superpower is self-hosting, so if your compliance team says memory stays in your building, that's your pick. You plug it in as MCP tools too.

Stella: And you run the server.

Liam: You do. Which is the whole point of Vilix AI. It's hosted in the cloud, so there's zero infrastructure. And recall is semantic plus keyword search, so the agent finds what you meant, not only what you typed.

Stella: Okay, but my agents don't only live in Make. Last week I used Claude for the same client.

### Memory that leaves Make

Liam: And there's the wall. Every Make-native store stops at Make's edge. Your Claude session, your Codex task, your scheduled agent, none of them can see it.

Stella: So I brief each one separately. Every morning.

Liam: The human copy and paste again. With Vilix AI you connect each tool to the same account over MCP. Decisions, projects, full conversation history, they follow you into Claude, Codex, Cursor, OpenClaw, Hermes, and your Make scenarios.

Stella: And if two tools disagree?

Liam: Newest memory wins, and every save has a source label, so you see which tool wrote what.

Stella: Okay, clients. I know you're going to say clients.

Liam: I am. If you build Make automations for clients, give each client their own Vilix AI account, like a Gmail account that belongs to them. Every scenario you build for them connects to their account, and the memory belongs to their business. Nothing mixes between clients.

Stella: Before the verdict, how do I test it?

### The verdict

Liam: Save a decision from a Make run. Open Claude. Ask about it. If Claude answers, you're set.

Stella: Verdict time. Which of the seven?

Liam: All inside Make, tiny state? Data Stores. Customer chats? A stable Conversation ID. Need to open and read it? A sheet. Self-hosting rule? Mem0. And when the pain is "I re-brief every agent, every morning", one shared Vilix AI memory.

Liam: The full guide, the blog post and Vilix AI are linked in the description. Which of your agents forgets the most? Tell us in the comments. See you next time!
