Knowledge Factory: How AI Agents Learn Your Company (Harrison Chase)
Harrison Chase explains why company AI agents need better knowledge, not better models, and how a knowledge factory collects, curates and maintains it. Bob and Alice unpack skills, curator agents and agent memory, then test the idea against research. In this episode: - Context versus knowledge, and tacit know-how - Agents that flag gaps, and a curator agent that fixes them - Risks: misleading retrievals, context poisoning Sources: Harrison Chase; Lilian Weng; Anthropic; Linda Zeng et al.; Simon Willison; Drew Breunig Big AI ideas, made clear for builders. luongnv.com/podcast
Listen on Build Wiz AI Show Download MP3 Transcript
Based on How to build a knowledge factory by Harrison Chase (@hwchase17)
Transcript
Bob: What if the thing holding back AI at your company isn't the model at all?
Alice: Harrison Chase says the missing bit is better knowledge. The kind your best people carry around in their heads.
Bob: Welcome to Build Wiz AI Show. Big AI ideas, made clear for builders. I'm Bob, here with Alice. Today: how to get what your best people know into your agents. Alice, what are we reading?
Alice: An X article by Harrison Chase, "How to build a knowledge factory". He writes that all the agents at LangChain, including their internal go-to-market and content agents, share a learning loop with similar pieces. Then he lays out those pieces.
Bob: Big claim first. Models keep improving. Why isn't that enough?
Alice: Because the model doesn't know your company. Chase says the missing piece is knowledge of how your company works, what standards you operate by, where data is stored and how it's accessed.
Bob: And that knowledge lives... where?
Alice: In your best people's heads. They know who to talk to, where to go to answer questions, why you do things a particular way. He calls that knowledge tacit, implicit and scattered.
Bob: Tacit. Give me the novice version.
Alice: Picture a family recipe nobody ever wrote down: grandma just knows when the sauce is ready. Map that back, and tacit knowledge is what a company runs on that sits only in someone's head, or scattered across documents.
Bob: Does memory research have a name for that?
Alice: Close to it. Lilian Weng, in her Lil'Log post "LLM Powered Autonomous Agents", describes implicit or procedural memory as unconscious skills and routines. Her example: "like riding a bike or typing on a keyboard".
Bob: So you can ride the bike, but you can't write the manual.
Alice: Exactly! So Chase's fix is to collect, curate and maintain a representation of that knowledge to pass to agents. He calls the system that does this a knowledge factory, and Anthropic's skills post voices a similar hope: helping organizations share their context and workflows.
Bob: Wait, though. Isn't that just context? Stuff the agent gets in its prompt?
Alice: He splits the two. Context is what an agent has available when doing a task. Knowledge is the reusable understanding that lets it do the task correctly: what a metric means, which source to trust, how a situation is handled.
Bob: Still a bit abstract for me.
Alice: Think of a delivery driver: today's route sheet is the context, and knowing which back gate is locked after dark is the knowledge. The factory turns scattered documents and experience into that second kind, which then becomes context for future work.
Bob: So knowledge is just one part of the context?
Alice: Right: data you already store reliably can just be handed over directly. Weng's post draws a similar line: short-term memory is in-context learning, limited by the context window. Long-term memory is an external store the agent retrieves from at query time.
Bob: Where does the word factory come from?
Alice: From software. Chase notes that the idea of software factories has risen sharply over the past year and a half. Your best engineers build the systems that help everyone build software, and agents do the actual building.
Bob: And the rest of knowledge work?
Alice: He says it's following a similar path, and agents now need all that tacit, scattered knowledge. It's like a head chef who stops cooking every plate and designs the kitchen, so the whole crew cooks better. The kitchen is the factory that collects, curates and maintains knowledge.
Bob: Love it, the chef becomes the architect. So what goes into this factory?
Alice: He names three kinds: skills, which is how to do the work; domain knowledge, how the business works; and data access guidance, where to get current information.
Bob: Skills first. What's a skill here?
Alice: Instructions and scripts for doing tasks the particular way your company requires. Chase says these were often never written down, just passed from coworker to coworker. Anthropic's skills post calls this capturing and sharing procedural knowledge.
Bob: Is there a standard format?
Alice: Anthropic's engineering post "Equipping agents with Agent Skills" describes skills as folders of instructions, scripts and resources that agents can discover and load. The agent sees only each skill's name and description at first, and reads the full file when the skill fits the task.
Bob: And the other two kinds?
Alice: Imagine a new hire's first-week binder with three tabs: how we do things, what we sell and to whom, and where the files live. Anthropic reaches for the same picture: a skill is like an onboarding guide for a new hire. Domain knowledge is the middle tab: core facts about people, products and competitors, usually incomplete or incorrect somewhere.
Bob: And the third tab, where the files live?
Alice: That's data access guidance. If your source of truth, in Snowflake or Databricks say, is complete and up to date, don't copy it. Maintain clear instructions on what data lives where and how to query it.
Bob: Okay, so who writes all of this? Please don't say me.
Alice: Not you, and not by hand: Chase calls manual upkeep a herculean effort. The first piece of the factory is a way for agents to flag missing knowledge as they work.
Bob: Flag it how, exactly?
Alice: Picture the sticky notes on a family fridge: whoever finds the milk gone writes it down, so nobody has to audit the fridge. Here, the agent gets a tool to report what's wrong, and optionally suggest the correct update.
Bob: Isn't some information better than none? Maya?
Maya: Not always. In a paper on arXiv, Linda Zeng and colleagues built a benchmark called RAGuard from real Reddit discussions. It sorts retrieved evidence into three types: supporting, misleading and unrelated.
Bob: And what happened?
Maya: When exposed to potentially misleading retrievals, every LLM-powered RAG system they tested did worse than its zero-shot baseline, meaning no retrieval at all. Human annotators consistently did better.
Bob: Wow. Bad knowledge can be worse than no knowledge. Why real Reddit posts, though?
Maya: Because mainstream benchmarks test clean retrieval or synthetic noise. The authors say those assumptions fail to reflect real-world conditions, often leading to an overestimation of how well RAG systems perform.
Bob: So, Alice, the flag really matters.
Alice: It does. Anthropic's skills post gives similar advice: find the gaps by running agents on representative tasks and observing where they struggle.
Bob: So the agents leave notes. Who reads the notes?
Alice: The curator agent. Chase says the agents using the knowledge are great at flagging, but fixing it requires deep understanding of the underlying knowledge and other sources of data.
Bob: Why not let every agent fix things as it goes?
Alice: Because those agents are mainly trying to accomplish their own goals. He warns that asking them to maintain the knowledge will make it unruly and full of contradictions.
Bob: Too many cooks in the kitchen again.
Lena: And that worry has a name. Drew Breunig, in his post "How Long Contexts Fail", calls it context clash: new information in the context that conflicts with other information already there. He says it creates internal contradictions that derail reasoning.
Bob: So who keeps the knowledge clean?
Alice: Picture a night librarian who reshelves the books and fixes the catalogue after everyone goes home. That's the curator: an agent running in the background on some cadence, with access to raw sources like Notion and Slack, to agent traces, and to everything the agents flagged.
Bob: Why the traces?
Alice: So it can see how people are trying to use the agents, and codify that into skills. Anthropic's post hopes agents will one day create, edit and evaluate skills on their own.
Bob: And where does all this knowledge actually live?
Alice: In some ways, he says, the least important part: skills in GitHub, a single file in Notion, a knowledge graph in Neo4j, and the curator agent should handle them all.
Bob: Least important. But?
Alice: But also the least explored. It's like arguing over a recipe box or a binder: the container matters less than whether the recipes are right, yet nobody agrees on the container. As an industry, he says, we've converged on skills for procedural memory, and Anthropic has published Agent Skills as an open standard.
Bob: Procedural memory again. Callback to the bike! Sam, how would you fence memory in?
Sam: Simon Willison, on Simon Willison's Weblog, wrote about chat memory. What he wants is "memory within projects": memory from previous chats, scoped to a project, so it doesn't leak into everything else.
Bob: Scoped knowledge. Noted. And the facts side?
Alice: Weng's post names the other kind: explicit memory of facts and events, which includes semantic memory, facts and concepts. For that, Chase expects a different standard to emerge, maybe one called OKF, and advises not being too prescriptive yet.
Bob: Make it concrete. His example?
Alice: An agent prepares a revenue report. The base context is the raw revenue numbers in BigQuery and Salesforce. The knowledge: a report-style skill, how the company calculates ARR from its wiki, and skills for querying that data.
Bob: And then something breaks.
Alice: Of course. Maybe a column was renamed in BigQuery, and the agent figures out the correct one on the fly. Then it uses its tool to flag the issue and suggest the proper column name.
Bob: And the humans?
Alice: Their finance lead works with the agent to fix some formatting, including a new header now needed on all their documents. That night, the curator sees the flag, inspects the traces of that back and forth, and updates the relevant skills.
Bob: So tomorrow's report gets it right the first time.
Alice: Think of it as a shift handover: the day crew leaves notes, the night crew fixes the manual, and the next crew starts ahead. Chase wants a system where doing the work reveals what knowledge is missing. It echoes Anthropic's tip: have the agent capture its successful approaches and common mistakes in a skill.
Bob: Time for some pushback. Sam, you've been itching to jump in.
Sam: A little. Simon Willison's bigger worry, in "I really don't like ChatGPT's new memory dossier", is control. About that newer memory, he wrote: "The new memory feature removes that control completely."
Bob: Why does control matter so much?
Sam: He says the entire game in prompting is to carefully control the context. In his case, remembered chats put a Half Moon Bay sign into a dog's pelican costume picture he never asked for.
Bob: A pelican costume. Okay, that's a vivid failure.
Sam: Vivid, but the lesson is serious. With the older feature, he could browse the notes at any time and delete the ones that weren't helpful. A curator that rewrites skills every night should leave people that same control.
Alice: Fair. My take: that's a strong argument for formats people can open and read, like skill files in GitHub that a teammate can review.
Bob: Lena, you've got a different worry.
Lena: Breunig's post "How Long Contexts Fail" also warns that longer contexts don't generate better responses. He describes context poisoning: when a hallucination or other error makes it into the context, where it is repeatedly referenced. One wrong fact in shared knowledge could spread that way.
Alice: Which is why one careful curator matters, not every agent writing. And Anthropic's skills post points to one guard: agents with a filesystem don't need to read a whole skill into their context window, only what the task needs.
Bob: One more from me: this is LangChain describing its own setup. Any numbers?
Alice: None in the post: it shares their learnings, not measurements. So my take is to treat it as a design to test on your own work, not a proven result.
Bob: Builder's Corner. Alice, one thing listeners can try this week.
Alice: Start with one recurring workflow, like a weekly report. Give that agent a simple tool to report what is wrong or missing, and optionally suggest the correct update.
Bob: And then I just read the flags?
Alice: Every week, yes. Play the curator by hand at first and fix the skill or document behind each flag. That's Chase's closing advice: inspect where agents struggle, and close that loop.
Bob: Small loop, real knowledge. I like it.
Alice: Takeaways, then. Mine: better models alone won't fix it. What's missing is better knowledge about your company.
Bob: Mine: three kinds of knowledge, skills, domain facts and data access guidance. And don't copy data that already has a reliable home.
Alice: And the loop: agents flag, a curator fixes, and wrong knowledge gets caught, which matters because Zeng's team found misleading retrievals made every system they tested worse than no retrieval.
Bob: And what's still open?
Alice: The format, for one. Chase says it's early and no standard has yet emerged for this kind of memory.
Bob: And who checks the curator? A night librarian nobody supervises makes me a bit nervous.
Alice: Same here. My guess: some human review of the curator's changes will matter, at least at first, and the post leaves that question open.
Bob: Thanks to Harrison Chase for his X article "How to build a knowledge factory". And to Lilian Weng on Lil'Log, Anthropic's Agent Skills post, Linda Zeng's team on arXiv, Simon Willison and Drew Breunig.
Alice: Go give one agent a way to flag what it doesn't know. That's all for today on Build Wiz AI Show. Thanks for listening, and see you next time.