Wink Pings

Knowledge Factory: Letting AI Teach Itself

LangChain's founder proposes the concept of a 'knowledge factory': the bottleneck to deploying AI in enterprises is not the model but maintainable knowledge. The piece breaks down three types of knowledge, three components, and a learning loop that lets AI improve itself.

LangChain founder Harrison Chase recently published a long post proposing a concept: the knowledge factory. He said that if you want AI to actually do work in a company, model size is no longer the bottleneck, and neither is context. The real bottleneck is knowledge.

What is a knowledge factory? Simply put, it is a mechanism that lets AI systems maintain and update knowledge themselves. At work, AI discovers what knowledge it lacks, then automatically fills the gaps, becoming smarter the more it is used. LangChain's internal marketing and content studio agents, as well as LangSmith Engine (an agent that analyzes run traces and gives remediation suggestions), are all running this loop.

Three types of knowledge

The knowledge factory maintains three types of knowledge.

The first is skills. The processes and scripts for completing tasks, such as 'produce reports in LangChain format'. This type of knowledge often goes unrecorded and is passed along only by word of mouth among colleagues.

The second is domain knowledge. Core information that does not easily become outdated, such as product definitions, customer segments, and company policies. It is usually written down, but often incomplete.

The third is data access guides. Which system the data is in and how to query it. The data itself does not need to be maintained repeatedly; what needs to be maintained is the access path.

Three components

Correspondingly, the factory consists of three parts.

The agent flagging mechanism. When an agent encounters information it cannot find or discovers that information is wrong while doing work, it should proactively report it, ideally with a suggested correction.

The curator agent. A maintenance role that runs periodically in the background. It reads raw data sources (Notion, Slack, etc.), looks at agent behavior traces, processes flagged reports, and then updates knowledge. This role cannot be held by the working agent as a side job; otherwise, the knowledge base will become increasingly messy.

The storage layer. GitHub, Notion, or a knowledge graph will all work. For procedural memory such as skills, a common format already exists, but there is still no unified standard for semantic memory. This is a problem the industry has not yet solved.

The article includes a complete example. An agent is preparing a revenue report. The underlying data is in BigQuery and Salesforce, the skills are in GitHub, the ARR calculation method is in the company wiki, and the data access methods exist as skills in Context Hub. During the run, the agent discovers that a column in BigQuery has been renamed, finds the correct column on the spot, and at the same time reports it using the flagging tool. That day, the finance lead interacts with it and has it change several formatting details. That night, the curator agent sees the flag, reviews the trace, and updates the corresponding skill. The next day, the agent knows to use the new column name and the new format.

Why it is worth paying attention to

Matt Stockton reposted this article and added a point: most teams are still at 'version 1'—turning processes into skills, documenting tacit knowledge, and giving agents tools to access data. That is already much better than not using a system at all. But the automatic improvement loop described in the article is something else: the system itself checks how knowledge is being used and then automatically improves the underlying components.

This line of thinking is an extension of the 'software factory'. The software factory means: the strongest engineers do not write code directly; they build systems that let everyone write code efficiently. General knowledge work is following the same path.

The most attractive part of this concept is that once the loop starts running, the system improves itself. In Harrison's own words: 'It feels like you built something that builds itself.'

There is a sharp point in the comments: the loop is the moat and the model is rented—the knowledge loop is the moat, and the model is merely rented.

Of course, implementation is not that smooth. One commenter said, don't let sub-agents touch the knowledge base directly, or it will quickly become a mess. Their approach is: sub-agents only report to the main agent, and the main agent decides what to change. Another commenter said that when two agents give contradictory edits to the same piece of knowledge, having the curator choose one at night amounts to papering over the disagreement; such conflicts should be left for humans to judge. Another commenter posted an image in the comments and asked everyone whether they thought this thing was interesting:

image

Harrison said the goal is not to document everything before starting work, but to build a system: the process of doing work exposes knowledge gaps, and after filling those gaps, the next time the work is done better. Start with the first repetitive workflow.

发布时间: 2026-11-22 13:42