Wink Pings

Models Are Depreciating, Knowledge Loops Are Gaining Value: LangChain's Knowledge Factory

LangChain's answer is called the knowledge factory: agents flag gaps as they work, and a curator agent turns those flags and run logs into reusable knowledge at night. Models are depreciating; loops are gaining value.

Harrison Chase published a long article on how LangChain builds a knowledge factory internally. His core judgment: when AI fails inside a company, the problem is often knowledge. Models and context are not the biggest missing pieces.

The most capable employees carry in their heads how the company actually runs: who to ask, where the data is, and why things are done this way. That knowledge is rarely written down; it is scattered across documents and individual experience. To get agents to truly do work, you first have to collect, curate, and maintain that knowledge, then feed it to the agents. Harrison calls this system a knowledge factory. Original article here: How to build a knowledge factory.

Inside LangChain, the GTM agent (go-to-market/sales-related), content agents, and LangSmith Engine (LangChain's agent for analyzing run logs and suggesting fixes) all run the same learning loop.

When Nicholas Charriere reposted it, he added a taxonomy: he calls an agent attached to a space a gardener, and one attached to a person a butler. He suspects we'll be hearing the term 'Knowledge Factories' a lot in the coming months.

Nicholas Charriere 对 agent 的分类

Harrison first distinguishes between context and knowledge: context is what an agent has available while doing a task; knowledge is reusable understanding that helps it get it right next time. A knowledge factory is a mechanism that continuously turns documents and experience into context.

He starts with the software factory analogy. Over the past year and a half, the concept of the software factory has heated up: the best engineers should not spend every day writing business code; they should build systems that let other people and agents write software together faster. General knowledge work is following the same path. Agents can create presentations, send outreach, and edit videos. What really limits them are the things only veteran employees know.

He breaks knowledge into three categories:

  • Skills: how to do things. Processes, instructions, and scripts—the methods for completing tasks according to company requirements.
  • Domain knowledge: how the business runs. Products, customers, competitors, and org structure.
  • Data access guidance: where to get current information. Which sources are trustworthy, where the data is, and how to query it.

The factory has three corresponding parts:

  • Agents discover missing or incorrect knowledge while working and report it with tools.
  • A curator agent (an agent responsible for updating and maintaining knowledge) periodically reviews flags and run logs in the background and updates knowledge.
  • The storage method itself matters less; GitHub, Notion, or Neo4j all work. The industry is beginning to converge on skill formats, but there is no standard yet for semantic memory.

Harrison emphasizes that the knowledge base should not be maintained by the same agent doing the work. Agents that use knowledge are good at spotting problems, but fixing them requires understanding the underlying knowledge and data sources. Letting a group of agents with their own goals maintain the knowledge base directly will produce a mess of contradictions.

The article includes a fairly concrete revenue report example. When an agent prepares a revenue report, it needs to use raw numbers from BigQuery and Salesforce and generate the report in LangChain's format. During the run, it discovers that a BigQuery column has been renamed, finds the new column on its own, and reports this with a tool. After the report comes out, the finance lead also changes several formatting details, including a new header. That night, the curator agent sees the flag, reviews the run logs, and updates both the data-retrieval and reporting skills.

A few additions in the comments are even more interesting than the article itself.

One commenter asked: who decides when knowledge is stale? Harrison said the curator agent can.

Another commenter has tried a similar approach. His experience: sub-agents are not allowed to directly change skills or knowledge. All sub-agents report only to an orchestrator (the main agent), and the orchestrator centrally decides what to change. Otherwise, things quickly become a mess.

There was also a sharp point: if two agents propose different changes to the same piece of knowledge, that doesn't necessarily mean it's stale; it more likely means it's ambiguous. If the curator agent picks one the next day, that effectively hides the disagreement. Conflicts should go into a human review queue, while individual flags should be merged automatically.

Will's summary was even harsher: the loop is the moat; the model is rented.

August Wittorp posted an image in a reply, asking whether this direction counts as relevant.

August Wittorp 在回复中贴的图

Harrison gave practical advice: don't wait until all your documents are organized before deploying an agent. Pick a recurring workflow, see where the agent gets stuck, and fill the gaps. As it keeps working, the knowledge will become more and more complete.

Models themselves will keep getting cheaper; the knowledge loops that build up around the business are what will be scarce.

发布时间: 2026-11-22 05:49