For the first few weeks, our AI agents were like new employees with no handover notes. Every conversation started from scratch. Decisions made on Tuesday were forgotten by Wednesday. Context from a client call lived in one agent's session and nobody else's.
That was fine when the team was small and everything lived in my head. But it doesn't scale. And it doesn't work when you're trying to build a genuine team — one where agents can hand off work, build on each other's decisions, and operate without me personally briefing every task.
So we built what we call the knowledge vault. Here's what we did, why, and what it actually changed.
The Problem We Were Solving
Three symptoms that made us realise we had a memory problem:
- Repeated context — Every new task required re-explaining the client, the project state, the decisions already made. Agents were spending significant context window on recap, not work.
- No shared state — Scout would update a task in Notion. Echo had no way to know. The team wasn't a team — it was six individuals who happened to share a language model.
- Context bleed — Long conversations would eventually degrade agent performance. The further back in a session, the less reliable the agent's recall.
The Architecture
We went with a Write-Ahead Log (WAL) protocol using Obsidian as the shared knowledge layer. Here's the core structure:
The WAL protocol means: every significant decision or context change gets written to the log immediately, before the agent responds to the user. If the session gets compacted or restarted, the agent reads the WAL on wake and knows exactly where it was.
The key insight
Memory isn't about storing everything. It's about storing what's actionable. A 10,000-word transcript is useless. A one-line decision summary with a "next step" is gold.
How It Works in Practice
Every agent has access to three memory files:
- SESSION-STATE.md — Active task state, current context, immediate next steps. Read on every session start.
- Daily notes (memory/YYYY-MM-DD.md) — Raw logs of what happened. Kept indefinitely, summaries decay out.
- MEMORY.md — Curated long-term memory. Only in main sessions. Never in shared contexts. Only read on direct chat with Jason.
On top of this, we have a shared Obsidian vault that all agents can read. Client notebooks, project histories, decision logs — everything that needs to survive beyond individual sessions.
What It Changed
After three weeks with the vault:
- New agent sessions start productive in under 60 seconds, without a human briefing
- Decisions made by any agent are findable by all agents within the hour
- Context window usage on routine tasks dropped ~40% — agents spend less time on recap
- Session compaction (when context gets tight) is now recoverable — agents read the WAL and pick up where they left off
The team actually feels like a team now. Not just six agents doing tasks in parallel.
What We'd Tell Past-Us
Build the memory architecture before you need it, not after you've already lost important context. Once you know what you're trying to remember, the implementation is straightforward. The hard part is agreeing on what matters enough to write down.
Start with: decisions, client context, active blockers, and next steps. Everything else is nice to have.
The one rule
If you complete significant work, or the user gives you a concrete detail — write it to the WAL before you respond. "Mental notes" don't survive session restarts. Files do.
What's Next
We're adding a RAG layer on top of the vault — so agents can semantically search past decisions, not just browse by date. That'll make the knowledge actually retrievable in context, not just stored.
If you're running a team of AI agents and they're all starting from scratch every session, this is the upgrade. It's not glamorous, but it's what separates agents that scale from agents that plateau.