Your Scheduled Agents Keep Erasing Each Other's Notes. Stop Letting Them.

Target query: can two AI agents share the same memory without overwriting each other (companion rewrite) Slug: two-scheduled-agents-share-one-memory-ghost Published: 2026-09-24 Surface: vilix.ai blog (full rewrite of the collision theme) Companion piece (dev.to): two-scheduled-agents-share-one-memory.md

At 6 AM a lead-triage agent saves a short note to shared memory: follow up on the stalled quote for Acme today. Fifteen minutes later a content-digest agent saves its own note to the same key: publish the weekly roundup. Only the roundup note survives. At 7 AM the triage agent reads its own memory, finds a priority that belongs to a different job, and spends the entire run acting on it.

Nobody configured anything wrong. The memory did exactly what shared memory does: the last write wins. The problem is that two automations were treating one shared notebook as two private ones.

The four ways automations collide

Most collisions fall into a small set of shapes. If you run more than one scheduled agent off shared memory, you will meet all four eventually.

Overlapping runs. A slow daily agent is still saving its results when the next scheduled run starts reading. The reader sees a half-written world.

Parallel fans. One workflow fans out to three agents at once and all three report into the same memory. Three writers, one notebook, no plan.

Duplicate keys. Two automations both keep a note called "today's priorities" or "customer list." Neither knows the other exists. Each run quietly deletes the other's work.

The status free-for-all. Every agent saves its run summary under a generic key like "latest run," so every new run wipes the previous one. History lasts exactly one run.

The result is worse than lost notes. The losing agent does not know it lost: it reads the winning agent's context and behaves as if it wrote it. Automations silently sabotaging automations, through the layer that was supposed to make them smarter.

Lane discipline: the four agreements

Shared recall across automations is worth keeping. The content agent should know the triage agent found a stalled quote; that might be this week's story. What you need is not private memory for everyone, it is an agreement about who writes what.

Agreement 1: private lanes for working notes, a shared lane for facts. The triage agent writes under triage/, the digest agent under digest/, and both read a small shared lane for company-level facts. Writers on different keys can never overwrite each other, and the shared lane stays curated because it is small.

Agreement 2: read before writing. An agent pulls the current version of any shared note, merges its update into it, and then saves. Correct once, in one place: since every connected agent reads the same store, and retrieval is recency-aware, the newest merged version is what every run sees.

Agreement 3: one owner for every rewritten key. A note like "today's top priority" gets exactly one writer: the agent whose job it is to set priorities. Other automations read it and append their own timestamped logs instead of rewriting it. If your digest agent keeps trampling the triage agent's note, the fix is ownership, not a cleverer merge.

Agreement 4: append logs, replace conclusions. Progress notes, incident timelines, and run logs accumulate as dated entries that are never overwritten. Only conclusions get replaced: the current priority list, the current account status, the final decision. Keeping the trail of how a conclusion changed is evidence you want preserved, not paved over.

Why a hosted shared-memory layer helps

You can implement all four agreements on any backend, but every bit of hand-built plumbing is a place where collisions sneak back in. A cloud-hosted memory layer like Vilix AI removes the database you would otherwise have to babysit:

• One store over MCP, zero infra. Every agent and workflow connects to the same memory, from n8n to cron scripts to Claude, Codex, Cursor, and headless agents. Hosted in the cloud; you manage nothing.
• Full conversation history, not just facts. Any agent can revisit the actual exchange behind a summary instead of guessing from a one-liner another automation wrote.
• Last write wins, with attribution. When two agents save conflicting info, the newest version becomes the truth going forward, retrieval stays recency-aware, and the store shows which client saved what. A note that looks wrong tells you which writer to fix.
• Nothing to lose. Pull everything out in a portable format anytime, delete individual memories or wipe the whole account instantly, on a free plan that never expires or a 7-day Pro trial that needs no credit card.

The discipline still lives in your agent instructions. The layer just makes sure you are disciplining one notebook, not a fleet of databases.

A five-minute audit

Before your next agent joins the shared memory, answer five questions: which keys are private and which are shared? For every shared key that gets rewritten, who is the one writer? What is append-only? Does every agent read a shared note before saving its update? And when a note looks wrong, can you see which agent wrote it?

Two agents can share one memory just fine. They just cannot share it the way strangers share a whiteboard: with no agreement about who writes where, the last marker out wins, and your automations spend their runs erasing each other instead of working.