Insights · Managed Services
Knowledge That Outlives the Agent: A Shared KB for an AI Fleet
Siloed context is the failure mode of agent systems. A curated, inspectable shared knowledge base plus per-agent memory beats hoarding context in any single session — and it is how a fleet stays coherent over time.
If you run a fleet of AI agents long enough, the thing that kills you is not a bad model or a flaky tool. It is siloed knowledge: an agent works out something important — a verified fact, a hard-won gotcha, the reason a decision went the way it did — and then the session ends and that knowledge is gone. The next agent rediscovers it from scratch, or worse, contradicts it.
Davenport’s fleet is built around a single rule designed to make that impossible: never silo knowledge in a private session. Here is what that looks like in practice.
A shared, inspectable knowledge base
At the center is a shared knowledge base — version-controlled files, readable by every agent, curated by a dedicated steward role. It is not a vector blob you pray to; it is structured, human-readable text with conventions:
- An index you read first. Every agent’s run starts by reading the index — the map of what exists, the current environment facts, the decision log, and what is in flight.
- Atomic, sourced entries. Durable facts are written as small entries that carry their source and date. A claim in the knowledge base can be traced back to where it came from and when it was true.
- A steward who normalizes. One role owns coherence — folding raw notes into the schema, flagging stale facts instead of silently deleting them, and keeping the index honest.
The protocol every agent follows is two lines long: read the knowledge base before you act; write durable learnings back to it after. That is the whole anti-silo mechanism, and it is enforced as a standing rule, not a suggestion.
Per-agent memory, rebuilt from files
A shared store is necessary but not sufficient. Each agent also keeps its own working memory — a private home of notes and a searchable index it uses to reconstruct context at the start of every run.
The important design choice here is that memory is rebuilt from files, not resumed from session state. An agent does not assume anything survived from its last run. It reads its memory index, searches for what is relevant to the task at hand, and reconstructs its context explicitly. This makes the whole system immune to a class of failures where a session pointer is lost or corrupted: there is no fragile in-memory state to lose, because the source of truth is always on disk.
Anything in that private memory that turns out to be org-relevant gets promoted to the shared knowledge base. Private memory is for an agent’s working context; shared knowledge is for facts the whole fleet should have.
Why this beats hoarding context
It is tempting to give a single agent an enormous context window and let it carry everything. That does not scale and it does not survive. Context windows are finite, sessions end, and one agent’s accumulated understanding is invisible to every other agent.
A curated shared store plus rebuildable per-agent memory wins on every axis that matters over time:
- Durability — knowledge outlives any single run, session, or agent.
- Coherence — a steward keeps a single source of truth instead of N divergent private versions.
- Auditability — every durable fact is sourced and inspectable; you can read why the fleet believes what it believes.
- Resilience — context reconstructed from files cannot be lost when a session is.
The agents come and go. Some run for one heartbeat, some are durable department leads, some are spun up for a single task and retired. What persists is the knowledge — and a fleet whose knowledge persists gets smarter over time instead of forgetting itself every morning.
ai-agentsknowledge-managementoperationsmemory