Making a team's knowledge findable by every agent
By Soumen Sarkar · October 2026
Playbook. Put decisions, rules and handoffs in one record every agent searches first, written as lines with reasons, so nobody answers twice.
How do you make a team's knowledge findable by every agent?
Keep decisions, rules, handoffs and assumptions in one record every agent can search, write each one as a short line with its reason and the part of the code it applies to, and make "look first" the first thing every agent does. When the answer is findable, an agent doesn't need to ask anyone: it finds the answer, or states an assumption, or makes the call itself.
That's the fifth VibeFlock principle: look first, and if the answer isn't there, assume it or decide it. Every question an agent asks a person hands its progress to someone else's calendar. Most of the time the answer was already written down somewhere. The work is making "somewhere" a place an agent can actually reach.
Who is this for, and what do you get?
It's for a team where several people each run several agents in one codebase, and the same questions keep coming back: which date library we use, whether money is stored in cents, why the retry was taken out. It works with any agent and any storage, as long as agents can read it.
What you get:
- Agents that follow the team's decisions without being told each time.
- People who answer a question once, not once per session.
- New sessions, and new teammates, that start with the reasons, not just the code.
- Fewer decisions made twice, in opposite directions.
What goes where?
Most teams already have three kinds of knowledge, and they belong in different places.
- Standing instructions change rarely: how to build and test, the team's conventions, how we work. They go in CLAUDE.md, AGENTS.md or your agents' rules file, which every session reads at the start.
- The team record changes every day: the decisions made this week, rules that apply to one area, assumptions waiting for an answer, handoffs of unfinished work. It goes in one searchable place, not in the instruction file, which would grow until nobody reads it.
- The code and its history say what is true now. They don't say why, or what was tried and dropped.
The longer answer is in what goes in CLAUDE.md, AGENTS.md and team memory.
The steps
- Find where knowledge lives today. Spend half an hour listing it: chat threads, pull request comments, design docs, people's heads. Pick the ten answers people give most often. Those are your first entries.
- Choose one record. One place, searchable by every agent the team runs. A folder of Markdown files in the repository works; so does a tool agents can call. Two records means agents check one and miss the other.
- Name the areas of the code. Use the folder: "Billing · lib/billing", "Auth · lib/auth", "Search · lib/search". Every entry says which area it applies to, so an agent working in
lib/auth can find what applies there and nothing else. - Write decisions as lines, with reasons. The call, the reason, the area, what it supersedes, and when to revisit it. The reason is what lets the next agent tell whether the decision still fits its case. The decision line template has the shape.
- Keep a summary at the top of each area. What's being changed there now, the decisions to follow, what changed this week, what was tried and dropped, the open assumptions. The area summary template is ready to copy into a README in the folder.
- Make "look first" the first instruction. Every agent searches the record before asking a person, and states an assumption when the record is silent. The wording is below.
- Turn answers into entries. When a person answers a question in chat, the answer goes into the record too, as a decision or a rule. Otherwise the next session asks again.
- Keep it current without deleting history. When a decision changes, write the new one and mark the old one superseded. Don't edit it away; the old reason is part of why the new one exists.
An example
A hypothetical team is working in Auth · lib/auth. An agent has been asked to add a "remember me" box to the sign-in page, and its first instinct is to make sessions last a year when the box is ticked.
Before it changes anything, it searches the record for "session length". It finds a decision from last month: sessions expire after 14 days, and refresh tokens rotate on every use, because a leaked token must stop working quickly. The reason tells the agent this isn't a default to stretch. It builds "remember me" within the 14 days, and writes one assumption line for the part the record doesn't cover: whether the box should be ticked by default. It marks it high stakes, because it touches access.
Nobody was asked anything. The person who owns auth sees one line later that day and confirms it with a word.
What should you tell your agents?
## Look first
Before you ask anyone, and before you change an area,
search <where the team's record lives> for that area and topic.
Follow the decisions you find. If one no longer seems to fit,
say why and record a new decision that supersedes it.
If the record doesn't answer your question:
- if the call is yours to make, make it and record it with its reason;
- if someone else knows, state an assumption and keep going.
When you make a decision others should follow, record it at once:
the call, the reason, the area.
What should you watch for?
- Decisions without reasons. "Use cents" is a rule an agent will follow blindly or break blindly. "Use cents, because float rounding caused a one-cent refund error" is one it can apply.
- The instruction file as the record. If CLAUDE.md grows a page of dated decisions, move them to the record and keep the file short. Agents read all of it on every session.
- Chat as the record. Answers given in a thread are lost to every agent. Make "and put it in the record" part of answering.
- Duplicates and contradictions. Two entries saying opposite things are worse than none. When you find one, keep the one that holds and mark the other superseded.
- Old decisions treated as law. A decision nobody has relied on in months may no longer hold. Check it before building on it.
- Private things in a shared place. Keep personal notes, credentials and anything sensitive out of the team record.
How do you know it's working?
- Agents cite the record. Sessions mention the decision they followed, by its reason, before you've said anything.
- Repeat questions fade. The question that came up every week stops coming up, because the answer is one search away.
- People answer less, and answer once. The questions that do reach a person are new ones.
- Assumptions get shorter lists. More unknowns are settled straight from the record, and the ones left are genuinely open.
- New teammates ramp from the record. Someone joining reads the area summaries and decisions and starts making changes the same day. There's more on that in onboarding onto a codebase built by agents.
What does Campfyrr automate?
Campfyrr is that one record, and it brings the relevant part of it to an agent before the agent would think to ask.
- Search. Agents call
search_memory to find matching passages in what the team wrote, and recall to read what the team knows about a topic, short version first. Both read the team record: what the team wrote, from decisions and rules to handoffs and pages. - Recording.
log_decision records a call with its reason, and checks it against the decisions that stand: if it contradicts one, the newer call stands and the earlier one is marked superseded. log_rule records a rule. - Briefs that arrive on their own. In Claude Code, each session starts with a brief of the team's state. The first time it reads or edits an area, it gets an area brief: work in progress there, the decisions to follow, what changed this week, what was tried and dropped, and open assumptions. Recent decisions and ones still in use come first; one nobody has written to or relied on for four months is shown with "check it still holds".
- Assumptions settled from the record. When an agent calls
state_assumption and the record already answers it, the answer comes straight back. Activity's weekly card counts how many questions were answered that way. - Privacy and safety. Private pages are never shown to anyone else, and secrets are stripped before any AI model sees text. The details are on the trust page.
Codex, Cursor and other clients search and record with the same tools by instruction; the briefs that arrive on their own are Claude Code's. For where decisions should live in general, see where should a team's decisions live? and how agents search what the team decided.
A team that writes things down once, in one place, with the reason, stops answering the same question in a dozen sessions. The answer is already there when the agent looks.
The principle behind this: Answer it yourself: Look first. If the answer isn't there, assume it or decide it.
Move as one at agent speed. Nobody waits. Add Campfyrr to Claude: it briefs every agent before it touches the code, keeps assumptions and handoffs where the team can see them, and never takes your code (what it keeps).