Three agents. One writes first drafts. One checks facts and tone. One handles client-facing summaries. For weeks they contradicted each other constantly - different spellings, different price figures, different ways of describing what we do. The fix wasnt more prompting. It was a shared filing system they all read from before they do anything.

Why agents drift apart

Each agent session starts cold. It has no memory of what the others decided last Tuesday. So agent one calls something a “knowledge base,” agent two calls it a “vault,” and agent three calls it a “document store.” None of them are wrong. All of them are inconsistent. Your reader notices, even if they cant name why.

The root cause is that the rules only exist inside prompts, and prompts live in separate windows. The moment you close one, the rule is gone. What you need is rules that live on disk, outside any single agent, so every agent reads the same source.

The vault - exact folder shape

We keep one directory called _brain at the root of every project repo. Nothing fancy. Here is the literal structure:

_brain/
  00-identity.md          # who we are, one-paragraph version
  01-voice.md             # tone rules, banned words, spelling choices
  02-facts.md             # the only figures agents are allowed to cite
  03-clients.md           # real client names and approved descriptions
  04-pricing.md           # current public pricing tiers, verbatim
  05-decisions.md         # dated log of every rule change and why
  06-glossary.md          # canonical term for every concept we use

The two-digit prefix forces alphabetical order to match reading order. Agents load them in sequence. 00-identity first, so every subsequent file is interpreted through that lens.

What a real file looks like

Here is a trimmed version of our actual 06-glossary.md:

# Glossary - canonical terms
## USE THESE. No synonyms.

| Concept                  | Canonical term       | Never use                        |
|--------------------------|----------------------|----------------------------------|
| The shared rules folder  | vault                | knowledge base, doc store, brain |
| A task-specific AI       | agent                | bot, assistant, GPT              |
| A client’s monthly fee    | retainer             | subscription, ongoing fee        |
| First engagement         | audit                | review, assessment, scan         |

One table. Every agent reads it. “Vault” is the word. End of argument.

The one rule that stops contradictions

Every agent prompt starts with the same two lines, before any task instruction:

Read every file in _brain/ in filename order before you begin.
If a task instruction contradicts anything in _brain/, flag it. Do not silently override.

That second line is the important one. Without it, agents quietly pick whichever version suits the immediate task. With it, the agent surfaces the conflict and you resolve it once, in the vault, so all three agents benefit.

When you update a rule, you update one file. You add a dated entry to 05-decisions.md so you know why the rule changed. Every future session picks up the new version automatically.

How to wire this into your own setup

If you are using the OpenAI Assistants API, attach the vault files as a file search vector store and pass the store ID at thread creation:

POST https://api.openai.com/v1/threads
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

{
  "tool_resources": {
    "file_search": {
      "vector_store_ids": ["YOUR_VECTOR_STORE_ID"]
    }
  }
}

All three assistants share the same YOUR_VECTOR_STORE_ID. Change a file in the store, all three pick it up on their next run. No re-prompting required.

If you are running local agents with something like LangChain or a simple Python loop, just read the files into a string at startup and prepend them to every system message:

import os

def load_vault(path="_brain"):
    files = sorted(os.listdir(path))  # 00- prefix keeps order
    chunks = []
    for f in files:
        with open(os.path.join(path, f)) as fh:
            chunks.append(fh.read())
    return "\n\n".join(chunks)

VAULT = load_vault()
SYSTEM_PROMPT = VAULT + "\n\n" + YOUR_TASK_INSTRUCTION

Crude, but it works. The vault is plain text so token cost is low - ours runs to about 900 tokens total.

What this does not solve

The vault holds rules, not memory. It wont tell agent two what agent one decided about a specific client email this morning. For that you need a separate session log, which is a different problem. Start with the vault. Get consistency first. Shared memory is a layer you add once the foundations are stable.

Dont overcomplicate the files either. We started with twelve documents. We merged them down to seven because agents were retrieving contradictory guidance from files that overlapped. One concept, one file, one canonical answer.

The short version

  • Put your rules in a folder, not in a prompt.
  • Name files with a number prefix so load order is deterministic.
  • Keep a glossary. One term per concept, no synonyms.
  • Tell every agent to flag conflicts rather than resolve them silently.
  • Log every rule change with a date and a reason.

Thats the whole system. It took an afternoon to set up and it has saved hours of correction work every week since.

If you want to see how we apply this inside a real client build, the supply-chain document-extraction write-up is a good next read: how we saved 30 minutes per document with a three-agent pipeline. Or if you’d rather talk through your own setup, here’s what working with us looks like.