Your Gumloop Agent Learns From Every Chat. Your Scheduled Runs Still Start Blind.

Every weekday at 9am, your Gumloop agent runs the morning lead digest: pull the new leads, score them, drop the hot ones in Slack. In the chat window, this agent is getting sharper every week. You corrected it once — "always check the CRM before scoring" — and it rewrote its own instructions on the spot. It turned a good triage session into a reusable skill. On a schedule, it reviews its own recent conversations and proposes improvements to how it works.

This is the rare automation platform that actually built agent memory. Then Monday's 9am run flags a "brand new" competitor pricing change that it already flagged three weeks ago, and re-scores a lead it disqualified last Tuesday. The chat is compounding. The scheduled runs are not.

That is the Gumloop memory story in one line: the memory lives in the conversation, and every scheduled trigger starts a new one.

What Gumloop actually persists (credit where it is due)

Most automation platforms give scheduled agents nothing at all between runs. Gumloop is genuinely ahead of the pack here, and it is worth naming exactly what you get, because it shapes what you still need to build:

• Search Past Conversations, on by default. The agent can search and retrieve earlier conversations for context. Gumloop's own docs call it "the backbone of an agent that learns over time."
• Self-improving instructions. Correct the agent once in chat and it edits its own system prompt so the mistake does not repeat. The change persists across future conversations.
• Skills. After a run goes well, tell the agent to "turn this into a skill" and it captures your way of doing the work. It can update those skills itself later.
• Reflections. The agent reviews its recent conversations on a schedule and proposes improvements to its instructions and skills.
• Company Brain. Attach Google Drive, Notion, Slack, GitHub, or Confluence and the agent searches your real documents automatically, with citations, instead of guessing.
• Sandbox persistence. Installed packages and workspace files survive across conversations.
• A permanent, searchable chat archive. Every conversation is saved, renameable, and searchable — unless it was incognito, which is never saved and is excluded from reflections entirely.

That is a real memory stack. The mistake is assuming the scheduled run inherits it automatically.

The scheduled trigger starts a new conversation

Gumloop agents run on triggers: scheduled (every weekday at 9am), app events, or one-time. When the trigger fires, the agent starts work in a fresh conversation. It wakes up with its instructions, its skills, its Brain, its sandbox files. What it does not wake up with is yesterday's run — unless it goes looking for it.

That distinction is the entire gap. In chat, memory is continuity: the conversation is still open and the context is right there. On a schedule, memory is retrieval: the agent has to actively search past conversations to reconstruct what happened. Retrieval finds what the agent thinks to look for. It silently misses everything nobody thought to ask about.

And notice what reflections and self-improving instructions actually carry forward: improvements to instructions and skills, not facts about the world. "Always check the CRM first" survives. "The CRM was down on Tuesday, so that run's scores are unreliable" does not — unless it happened to land in a conversation the agent later decides to search.

Three ways the memory degrades over time

Summarization compacts the evidence. When a conversation approaches the model's context limit, Gumloop compacts older messages into a structured recap — Goal, Actions Taken, Key Data, Status, Next Steps — starting at 80% of the context window. Well designed, and still lossy. The recap keeps the shape of what happened and drops the texture: which lead scores were borderline, which "fact" the agent was only guessing at, what it chose not to do and why. Weeks later, the agent reads its own recap with complete confidence.

Subagents split the context. Delegation spins up subagents, and each one runs as its own conversation with its own context and sandbox. The parent reads the results, but the working detail — what the subagent saw, tried, and discarded — lives in the subagent's conversation. Your memory is now scattered across a tree of chats, and past-conversation search has to reassemble it.

The archive grows faster than the retrieval. Every scheduled run adds another conversation to the archive. Search keeps working, but the signal-to-noise ratio decays. By run 200, the agent is searching through 199 past conversations to figure out what mattered. Without curation, the memory that was supposed to compound becomes a haystack.

The two layers, and which one you own

Split Gumloop's memory into two layers and the fix becomes obvious:

1. The learning layer — instructions, skills, reflections, Brain, sandbox. This persists automatically and it is genuinely good. Keep using it.
2. The run-state layer — what happened in each run, what was decided, what turned out to be wrong, what the next run must know before it acts. Nothing persists this automatically. This one you wire yourself.

The DIY options are a spreadsheet or database ledger the agent reads and writes each run, or a Brain document the agent updates with a run log. Both work. Both live inside Gumloop, which is fine until the operation outgrows one platform.

That is where a shared memory layer fits. Vilix AI is a cloud-hosted memory layer — you manage no infrastructure — that connects to your AI tools over MCP, the open protocol. Point each tool at the same Vilix AI account and they all share one memory: what the Gumloop agent learned on Monday, your n8n workflow reads on Tuesday, your coding agent reads on Wednesday. It stores full conversation history, not just extracted facts, plus the derived memories, projects, tasks, and rules your agents accumulate. Retrieval is semantic plus keyword, so it finds what you meant and still matches exact strings like order IDs literally. It is free forever on the free plan, with a 7-day Pro trial that asks for no credit card, and you can export everything or delete it anytime in a portable format. The honest tradeoff: every tool still needs its own one-time MCP setup — one approval does not configure the others — and the memory is only as good as what your agents actually save into it. Details at vilix.ai.

What to do on Monday

Gumloop gave your agent a better memory than most platforms bother with. Use it for what it is: a learning layer that compounds inside conversations. But do not confuse the chat's memory with the schedule's memory. Give every scheduled agent an explicit run-state layer — a ledger, a run log, or a shared memory service — and make "read last run's notes before acting" the first step of every trigger. The agent that remembers yesterday is the one that stops repeating it.