Blog
When Knowledge Moves Up, Down or Out
Part 6 of Knowledge Up, Context Down, about how knowledge moves between levels. When knowledge moves up, how context flows down, what to remove, and who reviews.

New to this series? Start with the overview. Previous: part 5. Next: part 7.
Between the levels
When my proof of concept ended, I archived the repository and put the findings into an RFC for my team to discuss. That is knowledge moving up one level, from a project to the team, on purpose. Most knowledge doesn't move that deliberately. It stays in one person's notes, or it ends up in a shared space without anyone checking it.
Quick recap: the four levels are personal, project, team and organization (see the series overview). This part gives signals and principles for moving knowledge up, passing context down, and removing what's outdated.
I think both directions are needed: up, from personal notes to shared levels, and down, as context that lower levels build on. Without clear signals and principles, shared levels fill up with unchecked content, and context from above gets ignored.
The question for this part: when should knowledge move to another level?
Moving up: three signals
Signals that knowledge is ready to move up one level:
- Others need it. People keep asking for it, or another project or team will run into it. Knowledge that only helps you can stay personal.
- It holds beyond one case. It has worked more than once, and it stays valid after the project ends. One success can be luck.
- The AI keeps getting it wrong. Repeated mistakes usually mean context is missing one level up.
And it moves only when the owner of the receiving level agrees.
Others describe the same: Robert Overweg only adds research to his company's knowledge base once it seems grounded and useful (Tessl), and a survey of agent memory tools finds that who decides what gets stored matters more than the storage format (Remy).
In practice, I share useful things early, as a proposal, and the signals help the team decide whether to adopt it. Some teams adopt new things quickly, others wait until something has proven itself. Both are fine, as long as the team decides explicitly.
An example: skills
The clearest case of knowledge moving up that I've seen is agent skills. Say I write a skill for reviewing code. It works well for me, so I share it with my team. Later, other teams want it too.
Those two steps solve different problems. In a team, the problem is getting everyone the same skill. Across the organization, the problem is trust: a skill can run commands and read code, so the organization needs to know who maintains it and what it is allowed to do.
- Person → team
- The problem: everyone uses different agent tools, and copied files drift apart
- What helps: one install that gives everyone the same version, in every tool
- Example: APM; the skill goes in the team's manifest and lockfile
- Team → organization
- The problem: many teams, and nobody knows which skills are safe or still maintained
- What helps: a central set of approved skills, with rules on what is allowed
- Example: APM's policy engine and governance guide
Who reviews, without creating a bottleneck?
The owner of the receiving level decides whether something moves up. At organization level, that owner can become a bottleneck, just like one reviewer for all pull requests. Data governance has dealt with this problem for years.
The common answer is federated governance, one of the four principles of data mesh (Dehghani). Each domain owns and reviews its own data, and a central team sets the standards. Applied to the skills example, this is how I see it.
Inside my team, the steward reviews changes to the code-review skill. When the skill is offered to every team, a central reviewer shouldn't have to check every line of it. Instead, the organization sets a few standards that every shared skill must meet, such as a named maintainer and passing the automated checks. The team that owns the skill checks it against those standards. The central team maintains the standards, not every skill.
It also helps to write down who decides what:
- How the team does code reviews: the team decides, because it needs local knowledge.
- Which skills every team can install: the organization sets the standards and the owning team publishes, because it crosses team boundaries.
- Which data a shared skill may access: the organization decides, because it's a risk for the whole organization, not just one team.
This already works for data, so I wouldn't build a separate process for AI knowledge. I'd make it part of data governance, with the same owners and stewards. Knowledge for AI is a new use of an old discipline.
Moving down: add, don't contradict
Context flows down. What the organization defines applies to every team, what a team defines applies to its projects, and so on. Each level adds detail for its own work.
A lower level can add to what it inherits, but not go against it. For example: the organization's reference architecture names an approved cloud platform. A team adds its own conventions for that platform, and a project adds its own decisions on top. What a project shouldn't do is quietly pick another platform. Sometimes there is a good reason to deviate, for example a legacy system that can't move yet. Then make the exception explicit: write down what deviates, why, and who agreed, so people and agents can see it instead of guessing. If the same exception keeps coming up, that's a signal to change the rule one level up.
This matters even more with AI. An agent that gets conflicting instructions from two levels has to guess which one wins.
Removing: archive, don't just correct
Knowledge that nobody uses still has a cost: the AI keeps reading it and people keep trusting it.
When knowledge is no longer used, or has been replaced, archive it and remove it from AI context. Adding a correction next to the old version isn't enough. Researchers at UC Berkeley found that LLMs can answer with an old value even when the update is in context, a failure they call stale binding, and that even frontier reasoning models can fail to recover the current state (Guo et al., 2026).
Tooling can help here. kmctl includes an opt-in audit agent that reports pages that no longer match the code, so outdated knowledge is found instead of silently kept.
Summary
- Up
- When: it shows the signals above
- Who decides: the owner of the level above
- Down
- When: always; add to the context from above, don't contradict it
- Who decides: nobody, it applies automatically
- Out
- When: no longer used, or replaced
- Who decides: the owner of that level
Treat these signals and principles as a starting point, and adjust them to how your team works.
Open questions
- Which signals, like repeated questions or repeated mistakes, could an agent spot by itself and turn into a proposal for a person to approve?
- How do you measure whether moving knowledge up actually improved the AI's answers?
- Where does knowledge go that several teams share, but that doesn't apply to the whole organization?
For leaders: make decision rights explicit. Who decides what moves to organization level should not be a guess.
For developers: when you correct the same AI mistake twice, propose the fix one level up.
Further reading for leaders and developers:
- Dehghani, Data Mesh Principles: the original description of domain ownership and federated governance.
- Guo et al. (2026), stale binding: why an old fact in context can still win over its update.
Next, part 7: Where to Start With Knowledge for AI
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












