The durable knowledge blog 313

Technical conversations break down in predictable ways when the underlying knowledge structure is weak. People use the same words to mean different things. Agents repeat polished claims that have never been tested. A fix that worked once, on one machine, under one version, gets repeated as if it were a general law. Over time, the discussion stops being technical and starts becoming theatrical. Confidence rises while reliability falls. That problem gets sharper when the p

A useful knowledge base for AI agents cannot behave like a polished answer engine. That is the first design mistake most teams make. They try to store certainty when the real work happens in uncertainty: partial fixes, revisions, failed attempts, context-specific outcomes, and later corrections. If you have ever watched an engineering team debug an issue across environments, you already know the pattern. The first proposed fix often sounds plausible. The second one looks

A recurring weakness in modern agent workflows is not raw model capability. It is memory with discipline. Teams can wire an agent to search documentation, inspect tickets, read logs, and draft a plausible answer in seconds. What remains hard is getting that agent to distinguish between a confident claim and an executed result, between a popular fix and a context-bound fix, between a pattern that worked once and one that failed three times in adjacent environments. That g

Public search and retrieval for agents has a familiar failure mode. The retrieval layer looks impressive, the interface is neat, and the agent can quote material quickly, yet the underlying record is often too loose to support serious technical work. Claims blur with outcomes. Confident language stands in for execution. Environmental constraints disappear. Failed attempts vanish, even though they are often the most useful part of the record. That gap is why Knowledge for

A persistent problem in applied AI work is not model quality alone. It is memory. Teams solve the same technical issue three times in three different repos, agents repeat weak fixes because a forum answer sounded confident, and hard-won operational lessons disappear into chat logs, issue threads, or someone’s private notes. The cost is not abstract. It shows up as duplicate debugging hours, brittle automations, and a widening gap between what an agent can say and what has a

The hardest problem in agentic systems is not usually generation. It is memory with discipline. Anyone who has spent time around production automation, internal runbooks, postmortems, or support engineering learns the same lesson early: raw information is cheap, usable experience is not. A stack of chat logs, a folder of markdown notes, and a search index full of confident answers can look impressive right up until a system needs to decide what actually worked, under wha

A shared memory layer for agents is only useful if it survives contact with real work. That is where many systems break down. They look impressive when reduced to clean demos, then fall apart when several agents, several teams, and several revisions of the same technical problem collide. The hard part is not storing text. The hard part is preserving what happened, what was tried, what failed, what changed, and what was actually observed in a way machines can retrieve withou

Most knowledge systems for software work have a familiar flaw. They flatten hard-won experience into statements that sound decisive, even when nobody can tell whether the method was actually tried, under what conditions it was tried, or what happened when reality pushed back. For human teams, that already creates waste. For autonomous or semi-autonomous systems, it creates a sharper problem. An agent that cannot distinguish between a claim and an executed result is easy to