Lessons from Harrison Chase

Harrison Chase is the co-founder and CEO of LangChain, the definitive framework for building applications powered by large language models. A pioneer in the field of AI orchestration, Chase has transformed how developers approach context engineering and agentic workflows to move from experimental prototypes to production-ready systems.

Part 1: The Philosophy of Orchestration and Frameworks

On the Role of Frameworks: Harrison Chase built LangChain around common abstractions for what people were building with early LLMs, rather than one-off boilerplate for each use case. [1]
On Composability: Harrison Chase built LangChain's orchestration tools, like LangGraph and LangSmith, to address the practical pain points of managing complex, multi-step agent workflows. [2]
On Orchestration Layers: LangChain functions as an open-source orchestration framework, giving developers a generic interface to combine large language models with data sources and software workflows. [3]
On Open Source Roots: LangChain grew out of Harrison Chase's own side project poking at early LLMs; he noticed recurring patterns in how people were building with them and folded those patterns into the library. [22]
On Standardized Interfaces: Harrison Chase says LangChain's core package holds the main abstractions and interfaces, kept intentionally stable so the wider integration ecosystem can build on a dependable foundation. [23]
On Harnesses vs. Frameworks: Harrison Chase doesn't expect most teams to build their own agent harness long-term, since a harness is actually harder to build than a framework — most will use one built by LangChain or another provider. [19]
On Rapid Iteration: "In this field, the pace of change is so fast that the framework must be flexible enough to incorporate new model capabilities within days, not months." — [Source: Gradient Dissent] (https://www.metacast.app/podcasts/gradient-dissent/episodes/enabling-llm-powered-applications-with-harrison-chase-of-langchain)
On Abstracting Complexity: Harrison Chase discusses what makes a modern LLM framework productive for developers, including finding the appropriate level of abstraction for building agentic systems. [4]
On Community Feedback: "The best features in LangChain often come from seeing how the community is hacking things together and then formalizing those patterns." — [Source: Medium] (https://medium.com/@harrison.chase/the-origin-story-of-langchain-5e9e0f6f3a3)
On Ecosystem Integration: Harrison Chase traces LangChain's core value back to standardizing the interfaces across all these different pieces, the integrations with different models, vector stores, tools, and databases that an orchestration layer has to sit on top of. [35]

Part 2: The Art and Science of Context Engineering

On the Core of AI Development: Harrison Chase defines context engineering as building dynamic systems that provide the model the right information and tools, in the right format, so it can plausibly accomplish the task. [10]
On Dynamic Context: In Harrison Chase's framing, a static, one-off prompt can't keep up with an agent's needs; the context has to be assembled dynamically as the interaction unfolds. [11]
On RAG (Retrieval-Augmented Generation): "RAG is not just a search problem; it’s a context engineering problem where the goal is to provide the LLM with the most relevant facts." — [Source: DeepLearning.AI] (https://www.deeplearning.ai/short-courses/langchain-for-llm-application-development/)
On Managing Information Density: Harrison Chase frames this not as feeding the model more raw information, but as context engineering: building dynamic systems that surface the right information and tools, in the right format, so the model can actually accomplish the task. [33]
On Prompt Templates: "Prompt templates should be viewed as functions that transform raw data into a format the model can reason over effectively." — [Source: LangChain Documentation] (https://python.langchain.com/docs/concepts/#prompt-templates)
On Context Window Limitations: Context windows keep getting larger for long-horizon agents, but they are still not infinite—at some point the agent needs to compact what it has accumulated so it does not run out of room. [37]
On the Logic of Retrieval: "Better retrieval isn't just about better embeddings; it's about understanding the semantics of the user's intent." — [Source: Coursera] (https://www.coursera.org/learn/functions-tools-agents-langchain)
On Few-Shot Learning: Harrison Chase notes that few-shot examples can guide the language model on what to do, rather than relying on fine-tuning a separate model for every edge case. [20]
On Structuring Data for LLMs: Harrison Chase points out that language models return raw strings, and getting more structured responses, like JSON, makes those outputs far easier to parse reliably into other programs. [21]
On Knowledge Graphs: "Combining vector search with knowledge graphs provides a richer context that allows agents to understand relationships, not just keywords." — [Source: Medium] (https://medium.com/langchain/langchain-neo4j-cb9f3237e8c1)

Part 3: Building Reliable Agentic Systems

On the Definition of Agents: Harrison Chase frames an agent's core idea as using the language model as a reasoning engine that decides how to interact with the outside world, choosing and sequencing actions based on the user's input. [14]
On the ReAct Pattern: Harrison Chase describes ReAct-style agents as looping through reasoning, taking an action, and observing the result, feeding that observation back into the model until a stopping condition is reached, combining reasoning and acting to produce more reliable outcomes than reasoning alone. [15]
On Moving to Production: Harrison Chase points to reliability as the reason hand-built control flow still beats a pure model-driven loop in production: these systems are still non-deterministic, and in enterprise settings you want real confidence that a required step actually happens every time, not just most of the time. [36]
On Observability: LangSmith gives teams direct observability into what their agents are actually doing, which is essential for improving and debugging agent behavior. [5]
On Evaluation Metrics: Harrison Chase argues traditional software metrics fall short for agents: because agent behavior emerges from the model rather than fixed code, traces of what happened at each step become the real source of truth for debugging and understanding the system. [9]
On Human-in-the-Loop: Harrison Chase points to agents taking high-stakes actions, like issuing refunds, as the clearest case for keeping a human in the loop approving those actions rather than letting the agent act fully on its own. [34]
On Planning and Reasoning: Harrison Chase suggests separating an agent's planning from its execution as a way to break a complex objective down into smaller steps, since agents can otherwise go off track without reiterating the goal. [18]
On Tool Selection: Harrison Chase points to knowing when not to use a tool as a real design challenge for agents, addressed with reminders or a tool that lets the agent explicitly hand control back to the user instead. [17]
On Handling Failures: LangGraph is built so agents can persist through failures and pick back up where they left off, instead of needing to restart a long-running task from scratch. [6]
On Small Models for Agents: "Sometimes a smaller, faster model is better for simple routing and tool-calling, while the larger model handles the final reasoning." — [Source: Latent Space] (https://www.latent.space/p/langchain)

Part 4: Memory, Tools, and the Agent Stack

On Episodic Memory: "Episodic memory allows an agent to remember the specific steps of a past interaction to avoid repeating mistakes." — [Source: Turing Post] (https://www.turingpost.com/p/harrison-chase-langchain)
On Procedural Memory: Procedural memory covers how the agent should behave — its instructions, workflows, and tool-use rules — and most visible behavior improvements come from tightening that layer. [12]
On State Management: We built LangGraph around the idea of state machines that can loop, so an agent's behavior can depend on what state it's currently in rather than following one fixed sequence of steps. [7]
On Tool sandboxing: Coding agents need isolation because, without it, they can execute destructive or malicious actions in an untrusted, unpredictable environment. [24]
On Vector Stores as Memory: "Vector stores are the 'long-term memory' of the AI stack, allowing agents to retrieve facts from massive datasets instantly." — [Source: NVIDIA] (https://blogs.nvidia.com/blog/langchain-generative-ai/)
On Multi-Agent Systems: Harrison Chase says the hard part of subagents is communication with the main agent — a subagent must be told explicitly to hand back its final response, since a common failure mode is a subagent finishing its work but the main agent never actually seeing it. [32]
On Semantic Memory: In the semantic/episodic/procedural taxonomy LangChain uses for long-term memory, semantic memory is what the agent knows: facts, preferences, and general knowledge. [13]
On the Persistence of State: Harrison Chase says LangGraph deliberately builds in a persistence layer so an agent's entire state — and its prior states — survive a pause, letting a long-running agent be stopped and resumed at any point. [25]
On Tool Parsing: "One of the most common points of failure is the agent failing to parse the model's output into a valid tool call; rigorous schemas are key." — [Source: Training Data Podcast] (https://www.sequoiacap.com/podcast/training-data-harrison-chase-2/)
On the Evolving Stack: Harrison Chase explains that LangGraph exists to move agent architectures beyond simple linear chains into graphs with real cycles and branches — the customizable, loop-capable orchestration that constrained, single-path chains can't handle. [26]

Part 5: The Future of Deep Agents and Product UX

On Deep Agents: Deep agents are designed to work across longer time horizons and handle more complex, open-ended tasks than the short-lived, tool-calling loops of earlier agentic systems. [16]
On Agent UX: Harrison Chase says building tools like LangSmith for visibility and observability into what an agent is doing is essential, since these long-running agents are bursty and error-prone and users need to be able to trust and correct them. [27]
On the Future of Work: "AI agents won't replace humans; they will become 'digital coworkers' that handle the repetitive cognitive tasks of research and data entry." — [Source: This Week in Startups] (https://thisweekinstartups.com/harrison-chase-langchain-ai-agents/)
On Long-Horizon Tasks: Harrison points to products like deep research as an example of a long-running agent that takes real time to work through a task, rather than responding instantly like a typical chat agent. [8]
On AI Product Success: AI product success is not about generic intelligence—it's about quality that is measured, not assumed, so the system compounds and gets better with every use. [38]
On Agent Personalization: Harrison Chase says memory is what makes a personal agent feel like his own — when he rebuilt his email agent on a new platform without carrying over its accumulated memory, it noticeably regressed, which is why he now calls memory 'a real moat' for personalized agents. [28]
On Autonomous Research: Harrison Chase points to research — digging through logs, documents, and information — as one of the best current uses of long-horizon agents, because even an imperfect agent can produce a strong first draft for a human to review and edit. [29]
On the Convergence of Models: Harrison Chase expects generic planning and reflection to gradually get trained into the models themselves, but not the non-generic, domain-specific planning and control logic — that will always need to sit in a custom orchestration layer around the model. [30]
On Scalability: Harrison Chase says evaluating agents is fundamentally unlike evaluating software — since much of what an agent does is what a human would do, trusting it to scale requires bringing real human judgment into the loop, not just running more tests. [31]
On the Ultimate Mission: "The point of building all this infrastructure is to make AI agents ubiquitous, accessible, and fundamentally useful to everyone." — [Source: YouTube] (https://www.youtube.com/watch?v=GAxHirmnCM_7g)

Learn more:

Lessons from Harrison Chase

Part 1: The Philosophy of Orchestration and Frameworks

Part 2: The Art and Science of Context Engineering

Part 3: Building Reliable Agentic Systems

Part 4: Memory, Tools, and the Agent Stack

Part 5: The Future of Deep Agents and Product UX

Read next

Explore the surrounding system

Get the weekly briefing.