Two sides of one coin

Language models do not have a reasoning problem. For most work that is about information rather than, say, code, the models are strong enough already. What an agent can do depends less on the power of the model than on what it knows, and what it lacks is context. Supplying that context by hand, explaining the same situation again at the start of every session, is inefficient and does not scale. The context has to arrive on its own.

That context comes in two kinds, which can be called explicit and implicit knowledge, for want of better terms. The line between them is not sharp, and it does not simply run between written and spoken.

Explicit knowledge is what is stated clearly enough to leave little room for interpretation. Numbers are the most explicit form there is: the financials of a company, last month's revenue, what a watch and a power meter record about a week of training. None of that could be supplied by describing it. A well-formulated document comes close. People work in documents, the documents are shared, and over time they form a common understanding of a subject. Because everyone thinks differently, that common ground is the foundation for working together: it can be read again, and it lasts. Text is also less forgiving than speech. A vague or empty statement can pass unnoticed in a conversation, or leave the listeners confused rather than suspicious; written down, it stays where it can be checked.

Implicit knowledge is the rest: people talking to each other, ideas worked out in conversation, the way someone reacts, and a good part of what is written without being formulated properly. It is vague by nature, and what is meant often depends on how it is said. Most of it has never been recorded. It is also the side people are most sensitive about, because in conversation there are only words.

That implicit knowledge matters is rarely disputed. For a long time there was simply little use for it. Even where it was recorded, nobody could work through that many conversations and messages to find what was relevant in them. Two things change this at the same time. Transcription, which has existed for a long time, has become very good, so recording almost everything is now easy. And language models are good at finding patterns in material that looks like noise – what gets repeated, the way something is said, what never makes it into a document.

Recordings on their own, though, are dangerous. Even good transcription gets words wrong, and a single wrong word can turn the meaning of a sentence around. A misheard name attaches a statement to the wrong person, and everything built on that statement carries the error forward. Correcting this by hand does not scale. What corrects it is the other side: the calendar knows who was in the meeting, a register of people knows how their names are spelled, and against that record the wrong parts of a transcript can be fixed automatically. Past a certain volume, the occasional error that remains stops mattering much.

The dependency runs the other way as well. Explicit knowledge can be complete and still miss important details. A document says what it contains, not who asked for it or what that person needs it to be. The figures in a report say nothing about how the people behind them act. Explicit knowledge alone is not powerful. Implicit knowledge alone, unchecked, can be catastrophic. Explicit knowledge makes the implicit reliable, and implicit knowledge makes the explicit complete. That combination is what makes a knowledge layer self-healing: as new material comes in, each side keeps correcting and filling in the other, without anyone doing it by hand.

Collecting both sides is not yet the same as knowing something. A growing pile of transcripts, messages and chat histories is of little use to an agent, which would have to go through all of it every time and would run out of context long before it finished. What has to happen in between is distillation: the raw stream is read regularly and condensed into what is currently true, and whatever has been contradicted by later decisions or declared no longer relevant is set aside. Not everything belongs in it. An agent does not need to know what someone had for lunch; it does need to know what was discussed in the last session. When that works, a new session starts without explanation, because what happened this week is already there.

None of this makes the person obsolete. What such a layer provides is closer to an extended memory, with the agent acting on it and the person directing it. The value lies less in documents generated automatically from whatever was agreed in a meeting than in what happens when someone takes on a task: it gets done completely, nothing is forgotten, the important things come back up at the right moment, and a good part of the work is done without having to be explained first. Whatever still remains ambiguous can be cleared up along the way: the agent asks, and the person working on the task answers.

Knowledge kept this way also outlasts the people who produce it. When someone leaves a company, what they carried leaves with them. Handovers get written, materials consolidated, lists of important contacts compiled, and it is unclear whether anyone ever reads them, because nobody wants to read a handover. A layer that grows by itself over months and years does not depend on anyone reading it; the agent reads it whenever it is needed. The same holds at a smaller scale, where a team runs on shared understanding that does not carry over to the people who join later.

Once such a layer serves an organisation rather than one person, not everything in it is meant for everyone. Security, privacy and access control are what it has to be built around – protective where it needs to be, without losing what it makes possible.

More model power does not replace missing context. Models and agent harnesses are built by a small number of large providers, and they do that well. What they do not do, by design, is connect the heterogeneous systems of every company and every person. They can build connectors. Putting those connectors together and building an architecture around them is what lets a company mature in its use of AI and scale it. That makes the context layer the important part.