Models Are Rented; Knowledge Is Yours
LangChain founder Harrison Chase breaks down the knowledge factory system: turning company knowledge scattered across people’s brains and documents into skills that agents can use. The real moat lies in the loop of knowledge accumulation; the model itself can be swapped at any time.
In the coming months, the term “knowledge factory” will come up often. LangChain founder Harrison Chase wrote a long post about how companies can accumulate knowledge for AI. In the comments, Nicholas Charriere added a more vivid naming scheme: gardener and butler.
Harrison’s core observation is this: the most skilled employees at a company carry a body of tacit knowledge in their heads. They know who to ask about a problem, which table the data is in, and why a process has to work a certain way. This knowledge is rarely written down; it is scattered across documents, chat logs, and people’s minds. For AI inside a company to actually get work done, the bottleneck is not the model, nor the context window. The bottleneck is knowledge.
LangChain already has this system running internally. Agents for the marketing team and content team rely on it to get work done, and LangSmith Engine maintains a knowledge factory for each agent. LangSmith Engine is LangChain’s own agent, specifically used to analyze run records and provide fix suggestions.
Harrison first clarifies the concepts: context and knowledge are not the same thing. Context is what an agent has at hand while doing the current task. Knowledge is what it needs to know the next time it does a similar task, such as what a certain metric means, which data source is trustworthy, and how to handle a certain situation. The knowledge factory turns scattered documents and experience into context that can be reused in future tasks.
He divides the knowledge to be maintained into three categories:
- How to do the work: skills. Processes, instructions, scripts, and the ways a company expects work to be done. Most of this has never been written down and is only passed along by word of mouth among colleagues. It is worth writing down.
- How the business runs: domain knowledge. Definitions, policies, products, customers, competitors. This kind of knowledge does not expire quickly, but it is usually incomplete because the volume is too large.
- Where to get the latest information: data access guides. Which system the data is in, and how to query it. If the data infrastructure is reliable, you do not need to copy it; you only need to maintain clear access instructions.
The factory itself has three components.
A flagging mechanism. When an agent cannot find information while doing work, or discovers that information is wrong, it uses a tool to flag it. At minimum report the problem; ideally include a suggested fix.
A curator agent. It is responsible for updating and maintaining knowledge. This cannot rely on manual human maintenance; the workload is too large. Nor can it rely on working agents to make incidental edits: they have their own tasks, and the knowledge they edit will become increasingly messy. You need a background role that runs periodically, accesses original data sources (Notion, Slack), reads agent operation logs, and turns flagged issues and actual operations into skills.
Storage. Harrison says this is the least important part and also the least standardized. You can store skills as files in GitHub, put them in a document in Notion, use LangSmith’s Context Hub, or store them as a Neo4j knowledge graph. The industry is still early; do not make the format too complex.
Nicholas Charriere gave the curator agent a name: gardener. It is attached to a space, not to a person. He calls an agent centered on one person a butler, such as OpenClaw, Grok Bot, and Muse. The gardener guards an entire knowledge space, and every change affects everyone using that space. Someone commented that “gardener” is a good name because it raises a question that “butler” does not: who signs off. A butler is responsible only to one person, while the gardener’s changes affect everyone, so it may need a PR that the space owner can see.
The post includes a complete example.
An agent needs to prepare a revenue report. The underlying data is in BigQuery and Salesforce; this is context, and it is fetched directly. How to make the report in LangChain’s style is a skill, stored in a skill file in GitHub. How to calculate ARR (annual recurring revenue) is long-term knowledge, stored in the company wiki. How to query BigQuery and Salesforce is also a skill, placed in Context Hub.
After the agent starts running, it discovers that a column in BigQuery has been renamed. It finds the correct column name on the spot and also flags the change. After the report is done, the finance lead manually fixes a few formatting issues and adds one note: from now on, all LangChain documents should use the new header.
That night, the curator agent sees the flag, checks the operation logs, notices this conversation, and updates the skill: use the new column name for data retrieval, and use the new header for reports. The next time, this agent will not fall into the same pit again.
Someone in the comments directly posted an image and asked whether this approach is somewhat interesting.
There were also more practical discussions.
One commenter said, do not let subagents directly touch skills or the knowledge base. He tried it; every subagent made its own changes, and it quickly became a mess. Now subagents only report, and the orchestrator makes all changes centrally.
Someone asked whether old fixes should be kept as test cases to prevent new skills from reverting old skills. Someone else asked how to judge what knowledge is worth keeping, and Harrison said you need a good gardener.
Someone else said that after the gardener modifies knowledge, it should notify the agents currently using that knowledge; otherwise they will run an entire task with outdated advice. Nicholas said that in the future there will be richer messaging mechanisms between agents. By then, butlers will not directly go into the garden to change things, nor will they give any agent write access to their own Notion. The butler expresses intent to the gardener, and the gardener is responsible for providing context and performing writes.
At the end of the post, Harrison gives a counterintuitive suggestion: do not try to document everything first and then let agents start working. Build a system in which the work process exposes knowledge gaps; after filling them, the next time is better. Start with a frequently reused workflow, observe where the agent gets stuck, and close the loop.
Someone in the comments summarized it more briefly: the loop is the moat, and the model is rented. The model can be swapped at any time; knowledge and the loop that accumulates knowledge are what you truly own. Some call this kind of thing a janitor, and some call it Thoth. The name does not matter; what matters is whether the loop is running.
发布时间: 2026-11-22 20:10