Your Make AI Agent Remembers the Thread. Your Scheduled Runs Still Wake Up Blank.

Make shipped a native AI agent this year, and on paper it looks like the end of glue-code automation. You pick the model (Anthropic, OpenAI, or Gemini), upload knowledge files so it knows your org, give it tools from Make's integration library, and talk to it from Slack. One automation reviewer who ran it through three real tests called the knowledge files genuinely useful, the tool access powerful out of the box, and then hit the wall in test three: memory. Quote: "The biggest limitation: no memory between messages."

That was the standalone agent experience. Make's own documentation gives a partial answer to the memory question. The "Run an agent" module has a Thread ID field. Map a unique identifier, keep the same thread across messages, and the agent keeps the history of previous conversations inside that thread. The Make community's stock answer to "how do I manage sessions on a Make AI agent" is the same shape: save the state you care about to a Data Store, then load it back at the start of the next run.

So does the Make AI agent remember between runs? The honest answer has two parts: yes inside a thread, no across runs. And the difference matters more than it sounds.

What the Thread ID actually gives you

If you route every message through one thread ID, the agent sees the conversation history in that thread. That is real. A multi-message back-and-forth works inside a single thread, and for a Slack assistant that chats with you all day, it is enough.

But a thread is a conversation, not a run log. When a scenario fires at 2 AM, processes a batch of items, and ends, the next execution is a new run. You can hand every scheduled run the same thread ID and technically keep history, but look at what you get: one thread stuffed with every message from every run, growing without bound, full of noise, and an agent that has to sift a giant transcript to find what matters. Every run pays token cost for the whole history. And the transcript has no structure: no distinction between a decision, an outcome, and a throwaway line. In practice, operators do not run production agents this way.

Knowledge files do not fix it either. They are static documents you upload: org context, policies, reference material. They tell the agent what is true in general. They cannot tell it what happened last night.

What scheduled runs actually forget

Take a nightly lead-triage agent. Every evening it pulls the day's new leads, scores them, emails the good ones, and marks the junk. Last night it decided 12 leads were spam, found 3 that were ready to buy, and learned that leads from one particular landing page never convert.

Tonight it runs again with zero memory of those decisions. The 12 spam leads look new. Nothing was learned about the landing page. The agent re-reads the same signals, re-scores the same people, and makes the same calls, except slower, because it re-fetches everything it already knew yesterday and re-reasons through everything it already decided.

That is the compounding problem. The agent can execute the task forever without ever getting better at it. Every run is run one. You are paying LLM prices for a goldfish.

The three things operators actually do about it

First, the Data Store save/load pattern. Make's community recommends it, and it works: at the end of a run, save the state you care about to a key-value store; at the start of the next run, load it back. The catch is that you design the schema, you decide in advance what is worth saving, and every new thing the agent should remember is a new field you add by hand. It is a filing cabinet, not a memory.

Second, the one-mega-thread trick: pass the same thread ID to every run. It is cheap and it technically persists, but it degrades exactly the way you would expect. History bloat, climbing token costs, and a raw transcript that was never designed to be queried. A summary-less transcript is a terrible memory format.

Third, an external memory layer. The agent reads a memory at the start of the run and writes to it at the end. Decisions, outcomes, lessons: not just messages. Read last night's verdicts before scoring tonight's leads. Write tonight's verdicts for tomorrow morning. Now the agent compounds. Run 100 is visibly smarter than run 1, because it stands on the other 99.

That third option is what turns an automation into something that learns. And it does not have to be built by hand. Vilix AI is built for exactly this gap. It is cloud-hosted with zero infrastructure to manage, one shared memory over MCP, so the same memory follows your agent across Make, n8n, Claude Code, your phone apps, every tool. It stores full conversation history, not just facts, so a run can revisit what was actually said, not a summary of a summary. The free plan is free forever, the 7-day Pro trial needs no credit card, and your data stays portable: export everything or delete it anytime in a portable format.

Thread IDs give your agent a conversation. Memory gives it a career. If your Make agent runs on a schedule, ask yourself what it learned this week. If the answer is nothing, the thread was never the problem. The run was.