A new engineer's first week is expensive. Nobody blames the person — the repo has conventions that live in other people's heads, and the only way to load them is to get pulled over repeatedly. Agents joining a team hit the exact same wall, and the fix has less to do with bigger context windows than with inheritance: deciding what a new agent is allowed to know before it makes its first mistake.
We ran the comparison ourselves. Same repository, two agents, three tasks each. One started from zero. The other loaded inherited experience before picking up its first ticket. The interesting part is where the gap showed up — not on task one, but on tasks two and three, where the from-scratch agent re-committed errors that had already been rejected, argued about, and fixed by other agents months earlier.
For inheritance to work, an experience entry has to be more than a saved prompt. In our implementation — the open-source collaboration platform Octo has this as its core layer — each entry carries four things: a verifiable behavior rule ("wrap external calls in the project's IoError type, never swallow exceptions at the UI layer"), a source link pointing back to the exact review rejection that produced it, a scope that keeps it inside one repo or module, and a confidence score gated by human approval. Distillation can be automated; activation cannot. That gate matters more than it sounds: wrong rules spread faster than right ones.
The injection path is boring infrastructure, which is the point. When an agent accepts a task, the runtime queries a preference server by repo, path, and keywords, pulls entries above the confidence threshold, and prepends them to the context before planning starts. Storage is server-side, so experience survives machine changes and runtime swaps — an agent running Codex and an agent running OpenClaw read the same library for the same repo. The model consumes experience but never writes activated experience; that one-way rule is what keeps an agent from legislating for itself.
Our from-scratch agent caught up by task three, as expected — the gap is front-loaded. What inheritance actually saves is the re-stepping-on-known-landmines tax, not the encountering-new-landmines tax, and new landmines are what incremental accumulation is for. If you're evaluating whether your team needs this, one metric is enough: count how often the same rule fires a second time in the same repo. While that number is nonzero, humans are paying for memory the system should have.
The entry schema, distillation timing, and injection strategy are all in the open repo if you want to argue with the design: https://github.com/Mininglamp-AI/Octo — a star while you're there helps.
