Wink Pings

LangChain’s Knowledge Factory: Replicating Experienced Employees’ Knowledge into Agents

Harrison Chase published a long post breaking down LangChain’s internal knowledge factory: three types of knowledge, two roles, and a revenue-report closed loop that makes agents get better with use. The comments also pressed on knowledge expiration and permission control.

LangChain (the company that builds an AI agent development framework) has all its internal AI agents running a learning loop. Harrison Chase, LangChain's CEO, published a long article on November 22 that breaks this loop down. The article is titled 'How to build a knowledge factory'.

Chase's core point: For AI to actually do work in a company, what's often missing isn't a better model, and it isn't just more context. What's missing is knowledge: how the company operates, what the operating standards are, where the data is, and how to get it.

Most experienced employees have this stuff in their heads. They know who to ask, where the data is, and why the company does things this way. But this knowledge is usually tacit, scattered across documents and chat logs. To perform well, agents need the same knowledge.

Chase calls this system a knowledge factory. LangChain is already using it internally: GTM (go-to-market) agents, content agents, and LangSmith Engine (an agent that automatically suggests fixes based on run records) all have similar learning loops.

Knowledge Is Not Context

Chase draws a distinction: Context is the information an agent has at hand when doing a task. Knowledge is reusable understanding: what a given metric means, which data source is trustworthy, and how to handle a certain type of situation. The knowledge factory turns scattered documents and experience into context that can be reused later.

Three Types of Knowledge That Need Maintenance

Skills: how to do the work. The processes, scripts, and standards the company requires. For example, reports need to be written in LangChain style. This kind of knowledge often used to go unwritten and was passed down by word of mouth among colleagues.

Domain knowledge: how the business operates. Products, customers, competitors, organizational structure, metric definitions. This kind of information doesn't expire often, but there is a lot of it, and what is written down is often incomplete or outdated.

Data access guidance: where to get the latest data. Which system the data lives in, which source to use, and how to query it. The data itself doesn't need to be copied and maintained; what really needs maintenance is the guidance for accessing it.

The Factory's Two Roles

Maintaining knowledge can't be done by hand—it's too much work. Nor can the agents doing the work directly edit it, or they'll create a pile of contradictions. Chase's arrangement is:

When an agent is working and finds that knowledge is missing or wrong, it flags it with a tool, ideally with a suggested correction.

A curator agent (the administrator agent responsible for maintaining knowledge) runs periodically in the background, reads the flags, reads the agents' run logs, and reads original sources such as Notion and Slack, then updates the knowledge. In effect, the workers are responsible for finding problems, and the curator is responsible for making changes.

知识工厂示意图

The image is from the original tweet.

A Revenue Report Example

An agent needs to prepare a revenue report. It needs raw numbers from BigQuery (a data warehouse) and Salesforce (a CRM system) as context. It also needs three types of knowledge: reports must use LangChain formatting, how ARR (annual recurring revenue) is calculated, and how to retrieve the data.

Step one: the agent discovers that a column name in BigQuery has changed. It infers the correct column name from context, then uses a tool to report the issue with a suggestion.

Step two: after the report is written, the finance lead and the agent revise the format together—for example, requiring all LangChain documents to use a new header.

Step three: that night, the curator agent sees the flag and also reviews the agent's run logs. It finds the conversation with the finance lead. It then updates two skills: use the new column name when retrieving data, and use the new header when writing reports.

Step four: the finance lead made the request only once, and after that every report automatically uses the new header.

The same goes for the content agent: if you revise an opening in chat, that night the curator will write this revision into the writing skill.

At the end of the article, Chase says: The goal is not to write everything into documentation from the start, but to build a system where the work process exposes what knowledge is missing, and once it's filled in, the next time is better.

Several Key Follow-up Questions in the Comments

One user asked: Who determines when knowledge has expired? Can the loop only add and never delete? Chase replied: The curator should be able to retire old knowledge.

One user asked: How do you prevent one person's preference from becoming company policy? Chase replied: You need a good curator.

One user shared: He tried letting sub-agents directly edit knowledge, and it quickly became a mess. His approach is for sub-agents to report only to the orchestrator (the central coordinator), and for the orchestrator to make all changes. This is the same idea as Chase's curator design.

Another comment said: This learning loop is the moat; the model is just rented. That's a bit harsh, but it points to the value of the knowledge factory: making agents fit the company's actual operations more closely the more they are used, instead of starting from zero every time.

Original content from Harrison Chase's tweet and article: https://x.com/i/article/2124180107669766144

发布时间: 2026-11-23 05:10