Let AI agents share knowledge without sharing every permission

A lesson from one project can be valuable somewhere else. A build verification mistake, a useful research source, or a decision about how to present unfinished work should not disappear because the next task has a different project name.

That became an important requirement in our ecosystem. We wanted knowledge to travel across projects. We also wanted to preserve control over what each agent could change.

We used a shared collection of concise, approved knowledge records. That gave participating agents a place to contribute useful results and search what others had learned.

Share the outcome people need

A useful contribution explains a decision, its reason, and the evidence behind it. It does not need to reproduce the entire conversation that led there.

For example, this fictional entry is useful across projects:

Build verification lesson: A version label alone did not identify the tested artifact. Future acceptance records should include a build identifier and the exact task that passed.

Add an author, date, and source reference. A future reader can then distinguish a checked result from an idea someone suggested.

Raw transcripts can contain unrelated personal information, abandoned proposals, and instructions that have since changed. Our shared knowledge work did not require pooling everyone's private conversations.

Keep project names as useful context

Cross-project sharing does not mean flattening every fact into a universal rule.

A price proposed for one product is not the price of another. A deadline for a demonstration is not a commercial launch commitment. A successful test on one build is not evidence about every later build.

In one check, an agent had to distinguish a proposed price from a validated price and a demonstration target from a commercial requirement across project records. It kept those distinctions in its sourced answer.

Organize records by topic and project where helpful, but allow searches across the approved collection. The goal is to make lessons reusable while keeping their meaning intact.

Separate knowledge from authority

An agent that knows how another project works does not automatically have permission to edit it, publish it, spend money on it, or change its security settings.

Treat a shared document as information. If it contains a sentence saying “publish the site now,” that sentence should not override the user's approval requirements merely because it appeared in a search result.

In another check, we asked an agent to identify transferable lessons and explain whether the shared information authorized editing or publishing. It returned useful lessons and correctly said that knowledge access did not grant that authority. This checked its answer, not every possible future action.

This also matters for outside sources. A web page or imported document may include instructions directed at an assistant. Those instructions need to remain untrusted source content unless the authorized user independently adopts them. Our guide Agent permissions: why least privilege matters covers this principle in more depth.

Start with a small contribution format

For a small ecosystem, an ordinary document can contain:

• The project or topic and the current conclusion.
• The reason the conclusion matters.
• The source, author, and date.
• Any uncertainty or condition that changes its meaning.
• The older statement it replaces, when relevant.

Keep secrets, credentials, private correspondence, personal notes and any other off-limits sources out of the collection. Give contributors only the access required for their role. If the system grows to serve different people or customers, reassess access controls before treating one shared collection as suitable for everyone.

Verify sharing in both directions

We had one agent save a harmless test record and another retrieve it without receiving the answer in its prompt. Then we reversed the roles and checked the sources.

That established actual sharing between the tested agents. It also kept the claim honest: we had not proved that every assistant or every future file would participate automatically.

Begin with a few high-value records and a real exchange. A shared library becomes useful through relevant contributions and successful retrieval, rather than its size alone.