Episodic vs Semantic Memory for AI Agents: What Your Scheduled Automations Actually Need
Your scheduled agent wakes up on Tuesday and refunds a customer twice. When you ask why, it answers with total confidence: “Per your policy, refunds under $50 are auto-approved.” The policy is real. The rule is correct. And yet the decision was wrong, because on Monday’s run the agent already issued that refund manually and logged a note about it. It remembered the rule. It forgot the event.
Flip it around and you get the opposite failure: an agent that remembers every incident in vivid detail but never learns the pattern. It can tell you exactly what went wrong on September 12th, 13th, and 14th, and then it walks into the same failure on the 15th because nobody ever turned those incidents into a rule.
These are not two flavors of the same bug. They are two different memory systems, and most automation setups are missing at least one of them.
The two memories, in plain terms
The distinction comes from cognitive science. Tulving’s 1972 framework split human memory into episodic memory (specific events: what happened, when, to whom) and semantic memory (general facts: what is true regardless of when you learned it). The CoALA paper on cognitive architectures for language agents (2023) formalized the same split for agents, adding a third type: procedural memory, the learned routines.
For a scheduled agent, the mapping is concrete:
Episodic memory is the diary. Timestamped records of what actually happened. “On Monday’s 9 AM run, the Shopify API returned 429 rate-limit errors; the retry at 9:40 succeeded.” “Last Thursday’s triage run escalated the Acme ticket to Tier 2, and the customer replied Friday saying it was resolved.”
Semantic memory is the handbook. Timeless facts and rules distilled from experience. “Refund requests over $500 route to the billing team.” “The Shopify API allows 2 calls per second.” “Summaries for this user lead with metrics.”
Procedural memory is the muscle memory. Learned routines: “When the morning sweep finds zero new leads, skip the full report and post a one-line all-clear.” “Drafts for the support channel always include the ticket number in the first line.”
Most DIY agent memory setups store exactly one of these. A vector database of facts gives you semantic memory with no episodes. A chat-history log gives you episodes with no distilled facts. Both leave you exposed to the failure mode of the missing half.
What breaks when you only have one
Facts without episodes produces an agent that knows the rules but has no past. It can tell you the refund policy. It cannot tell you whether this specific refund was already issued. It cannot answer “what did the last run do?” or “did we try this approach on Tuesday?” That means it cannot resume a failed run, cannot detect when its own behavior drifted between runs, and cannot distinguish a fresh situation from a repeat. This is the agent that re-sends the follow-up email because the rule says to follow up, with no memory that the follow-up already went out.
Episodes without facts produces an agent with perfect recall and zero judgment. It remembers every failure in detail but never extracts the lesson, so the same correction has to be re-taught forever. You told it three times that billing questions go to #support-billing; each run’s transcript contains that correction, but the agent starts every morning’s reasoning from the same blank rulebook and invents the same wrong answer. Raw transcripts are not learning. Learning is what happens when episodes get consolidated into facts.
That consolidation step has a name in the research: reflection. The Generative Agents work (Park et al., 2023) showed agents periodically synthesizing recent episodes into higher-level insights and writing those to long-term memory. The practical implication is blunt: you cannot consolidate what you threw away. If your memory layer stores only summaries, the raw material that a future reflection pass would need is gone.
What this means for a scheduled agent in practice
If you run agents on a schedule in n8n, Make, Zapier, or a cron script, here is how to apply the split:
1. Store full conversation history, not pre-digested summaries. The full transcript is your episodic substrate. Summaries are fine as an index, but the moment you discard the raw conversation, you cap what the agent can ever learn from it. Full history is also what lets you audit a weird decision later: you can read what actually happened instead of trusting the summary’s version.
2. Promote repeated corrections to standing rules. When the same correction appears in two or three episodes, it stops being an incident and becomes a fact. “Billing questions go to #support-billing” should not live in Tuesday’s transcript; it should live in semantic memory where every future run picks it up without re-reading Tuesday.
3. Timestamp everything and let retrieval weigh recency. Episodic retrieval should prefer recent events; semantic retrieval should prefer established facts. When they conflict, the newer episode usually wins. This is the last-write-wins principle, and it is how you keep memory fresh instead of letting a six-month-old fact overrule yesterday’s reality.
4. Scope both memories. Episodic and semantic memory both need boundaries: per client, per workflow, per environment. A fact learned from client A’s data must never surface in client B’s run, and an incident from the staging workflow should not rewrite the production handbook.
The lazy version: one memory layer that keeps both
Building all of this yourself means a transcript store, a fact-extraction pipeline, a consolidation job, retrieval with recency weighting, and scoping rules, all of it hosted and maintained. That is a real engineering project, and for most operators it is not the project they wanted.
This is the gap Vilix AI is built for. It is a cloud-hosted memory layer, so there is no database to run and nothing to maintain. The same memory follows your agent across every tool over MCP: the n8n workflow, the cron script, Claude Code, the phone app, all reading and writing one shared store. It keeps full conversation history, not just extracted facts, so the episodic record survives for reflection and auditing, and facts and preferences persist as semantic memory any connected tool can retrieve. Retrieval stays fresh with last-write-wins semantics, and memory is scoped per user so one client’s episodes never leak into another’s runs.
The part operators care about most: the free plan is free forever, the Pro trial is 7 days with no credit card, and your data is portable. Export everything or delete it anytime, in a portable format, no lock-in.
If your scheduled agent keeps making the same mistake or keeps forgetting what it already did, the problem is rarely the prompt. It is usually that the agent has one kind of memory and needs the other. Give it both, and the 7 AM run stops being a fresh hire with no onboarding.