Blog
A Shared Way of Working That Everyone Can Check
Part 4 of Knowledge Up, Context Down, about team knowledge. Shared memory that people can inspect and correct.

New to this series? Start with the overview. Previous: part 3. Next: part 5.
The team level
In most teams I've worked with, everyone used their own AI tooling, with their own context and their own skills. Each setup worked for its owner. But reviewing each other's work took more effort, because there was no shared version of the truth to compare against. People did duplicate work, and everyone effectively built their own knowledge base.
The question for this part: how does a team keep one shared version of how it works, for both people and agents?
What belongs at this level
We often call this the way of working: the standards and practices used across projects. In practice it includes:
- Standards: what good work looks like, with real examples.
- Processes: how-tos, checklists, runbooks.
- Vocabulary: the terms the team uses, and what they mean.
- Recurring answers: the questions new members always ask.
The test for team knowledge is not whether it's officially approved, but whether it helps the next person doing the task.
Three requirements
1. People can see what the AI learned. Everyone on the team should be able to view, edit and delete what the AI remembers, and trace its behavior back to a specific memory. Memory that nobody can inspect is hard to trust.
In practice, that's easiest when the team's memory is plain files in the repository. You can read them, change them through a pull request, and use the history to see who added what and why. A simple test: when the agent does something unexpected, can someone on the team find out within a few minutes where it got that from? Many tools promise to handle team memory for you. But when the memory sits in a complex system you can't look into, that test is hard to pass, and so is trusting the result.
2. Personal memory is not team memory. Personal notes contain habits and assumptions that only hold for one person. Review them before adding them to a shared system.
3. Someone owns it. Shared knowledge without an owner gets outdated. Outdated knowledge is worse than none, because people and agents keep using it.
Start with a light routine
You don't need to choose a platform first. You need an owner and a habit.
- Name a knowledge steward: the person who keeps it up to date, not the one who writes everything. Rotate the role now and then.
- Plan a short, regular update: new decisions, changed processes, corrected memories.
- Clean up regularly: remove or archive what's outdated.
Tools
The tools are largely the same as at the project level (Part 3 – Project): team knowledge also lives in the repository. The difference is that the whole team shares one setup, across projects:
- The same format and tools as in projects, with the docs structured by Diátaxis: tutorials, how-tos, reference and explanation.
- The same skills for everyone, installed with APM for each agent tool, such as Claude Code and Google Antigravity. Skills are written once, and everyone works with the same agent setup.
- Direct access for agents through OKF's MCP server, so agents can search the knowledge instead of reading files one by one.
- Human review on every change, through pull requests with automated validation.
What we saw
The clearest result was onboarding. Without a shared setup, a new team member spends a lot of time finding out which tooling is out there, installing it and building their own agent setup. With the same skills and knowledge installed for everyone, that saves days before someone is effective. New team members, and their agents, start from the same knowledge as everyone else.
The second result is that projects learn from each other. A practice that worked in one project ends up in the shared setup, so the next project starts with it instead of finding it out again. Sharing what works between teams is the next step, and Part 6 – The flow covers when team knowledge should move up to the organization.
Open questions
- When the AI proposes a memory update, what should the steward check before approving it?
- When two team members correct the shared memory in opposite ways, who decides which version stays?
For leaders: plan time for the steward role, instead of expecting it on top of other work, and count a shared setup as team output, not side work.
For developers: put one skill or convention you rely on into the team's shared setup, so the next person doesn't have to rebuild it.
Further reading for developers:
- Diátaxis: a simple way to split documentation into tutorials, how-to guides, reference and explanation.
- okf-skills: a toolkit for working with OKF knowledge from your agent tools.
- Model Context Protocol: the open standard for connecting agents to tools and data sources.
Next, part 5: One Base Context for Every Team and Agent
Written by
Our Ideas
Explore More Blogs

Knowledge Up, Context Down
AI tools work better with the right context. This series covers four levels of knowledge, and when knowledge should move up, flow down or be removed.
Roel Bertens
Contact












