# "Five devs, five agents, five versions of the truth"

*"Per-machine agent memory drifts apart. A shared decision store gives every machine the same graph and the same recall, no LLM in the read path."*

Five devs, each with an agent, each agent hoarding its own local memory. Notes files, session summaries, whatever it accumulated on that machine. Ask where invoice logic lives now and you get five answers, two of which predate the billing extraction. Nobody's memory is wrong about what it saw. The machines just watched different movies.

Divergence is the default, because memory written locally stays local. Every decision made on one machine is a fact the other four don't have, and the gap compounds one decision at a time. The new teammate is the worst case, their agent starts from nothing at all.

What worked for us is making the store shared and the read path boring. We build kgai. Every decision is an immutable, content-addressed event appended to the writer's own shard. Sync is opt-in through an S3 bucket you own, no server of anyone's in the path, and every machine replays the shared log into the same graph, deterministically. Same log, same graph, same recall, on all five machines and on the sixth one that joins tomorrow.

A boring read path means no model in it. Recall is lexical matching plus graph traversal, no embeddings, no LLM call, so the same question against the same store gives the same answer on every machine, every time. The agent doing the asking bridges synonyms by rephrasing. The store never guesses.

Writes stay safe in parallel too. Each writer appends to their own shard, so five agents recording at once can't produce a textual conflict, there's nothing to merge. When two people genuinely decide the same thing two different ways, that's a real disagreement rather than a sync artifact, and it surfaces as a branch you resolve by recording one new decision. Both heads and the resolution stay in history.

This holds at sizes a team will actually hit. At a million decisions across 30 writers' shards, a decision lookup answers in about 100 ms. That figure is the decision lookup specifically, recall and free-text search are slower.

The day-to-day mechanics of sharing are in [share AI memory with your team](https://kgai.dev/blog/share-ai-memory-with-your-team), and what months of divergence do to a codebase is in [decision drift](https://kgai.dev/blog/decision-drift).

kgai ships as a Claude Code plugin with a standalone kg CLI, capture is automatic in sessions through a skill and hooks, local-first, MIT.

Two commands per machine and all five agents read the same memory. The comparison page covers where other tools fit better.

## Try kgai

Two commands, MIT, nothing leaves your machine until you configure a bucket:

```
claude plugin marketplace add kgaidev/kgai
claude plugin install kgai@kgai-marketplace
```

Source: https://github.com/kgaidev/kgai
See how kgai compares to other tools: https://kgai.dev/compare
All notes: https://kgai.dev/blog/

---

Canonical: https://kgai.dev/blog/five-devs-five-agents · Written by kgai maintainers · kgai is MIT open source