Harrison Chase

Harrison Chase created the LangChain open-source project and is co-founder and CEO of LangChain as of September 2026. His work concerns the software surrounding language models: reusable components that connect them to information and tools, debugging and evaluation, and agent harnesses that manage context and execution. He started LangChain as a personal project in 2022, founded the company with Ankush Gola in early 2023, and developed the initial Deep Agents package in 2025.[2][4][6]

Before LangChain, Chase studied statistics and computer science and worked in machine learning. That earlier career included an experiment with company knowledge that preceded his work on reusable LLM components.[1][11]

Chase studied statistics and computer science at Harvard, then worked as a machine-learning engineer at Kensho Technologies and at Robust Intelligence, where his work involved testing and validating machine-learning models. In his 2023 Latent Space interview, he traced his entry into coding to Harvard’s Sports Analytics Collective: he began with basic statistics in Excel, then learned programming, data science and machine learning to pursue more advanced analysis. He valued sports as a learning environment because people cared about predictions and game results provided quick feedback.[11][1]

At a Robust Intelligence hackathon, Chase recalled working with a colleague named Will and two other colleagues on a bot that answered questions using Notion and Slack. It was an early experiment in retrieval-augmented generation: bringing company information into a language model’s answers. He remembered it as one of his first LLM applications, while remaining uncertain about the exact sequence of those experiments.[1]

Chase’s account of LangChain’s origin centers on generative-AI meetups in August and September 2022. While considering what to do after leaving his job, he noticed developers repeatedly assembling similar pieces and decided to factor out common abstractions as a side project. Early examples included Nat Friedman’s NatBot browser agent and LLM Math Chain. The first LangChain Python package was released on October 24, 2022. Chase and Gola subsequently started LangChain the company in early 2023.[1][3][4]

Composability was the organizing idea: developers could assemble prompts, retrieval, model calls, tools and application logic into a larger program. A document-question-answering chain, for example, retrieves relevant material, combines it with the question and possibly chat history, then calls a model to generate an answer. Chase also emphasized model optionality, allowing developers to try different providers or switch as cost and capabilities changed. He attached a practical qualification: “Prompts don't really transfer.”[3][1]

One of Chase’s favorite retrieval mechanisms was self-query retrieval, which separates semantic meaning from explicit constraints. His example was a request for movies about aliens in 1980: “aliens” supplies the semantic search, while the year becomes a metadata filter. That distinction lets retrieval respect a precise condition rather than relying entirely on similarity between embedded text.[1]

Responding to criticism of LangChain in 2023, Chase acknowledged that directly calling a provider’s API was the simplest approach when that was all an application needed. For more complex applications, he described changes to documentation, prompt visibility and customization. He connected LangSmith to the difficulty of debugging chains and agents: traces expose each step’s inputs and outputs, and useful production examples can become evaluation datasets. Evaluation runs retain those traces so developers can inspect failures beyond a final score.[1]

Chase distinguished a chain, whose steps follow a specified sequence, from an agent, in which the model decides some steps and their order. His 2023 recommendation was to start with chains and introduce model-directed reasoning when concrete edge cases required it. A SQL agent, for example, could recover from an invalid query or reconsider which tables to use. He also recommended limits on execution and observability to keep that flexibility under control.[1]

The LangChain team’s January 17, 2024 LangGraph announcement described graph-based state machines for controlled agent loops. Nodes perform work and update shared state; edges specify fixed or conditional routes, including termination. Its retrieval example lets a model recognize inadequate documents, refine its query and search again. Developers can constrain the loop by forcing an initial tool call or inserting human approval.[5]

In a September 2024 discussion with Shunyu Yao, Chase explained ReAct’s appeal as combining reasoning with actions that obtain external information or call APIs. He distinguished that general idea from the paper’s original prompting strategy: later tool-calling loops retained related ideas through a different implementation. He also proposed judging architectures partly by how likely they were to remain useful when the next generation of models arrived.[12]

In his July 30, 2025 Deep Agents essay, Chase reported building an initial open-source package over a weekend to generalize patterns he saw primarily in Claude Code, including accounts of its use beyond coding. He proposed four additions around a tool-calling loop: detailed instructions, a planning tool, subagents and a filesystem. The initial Todo tool performed no operational work; Chase described it as a context-management strategy for keeping the model on track. Subagents divided tasks, while a virtual filesystem backed by agent state held notes and accumulated context.[6]

The Deep Agents repository describes the subsequent harness as a configurable layer above LangChain’s create_agent, which runs on LangGraph. Its documented context mechanisms include isolated subagent contexts, conversation summarization and moving tool outputs into files. It also provides filesystem backends, persistent memory and human approval of tool calls.[7]

By July 2026, Chase and Nick Hollon were reconsidering parts of the original design. They described using benchmarks to decide whether a prospective Deep Agents 0.7 release could remove Todo-list middleware and substantially shorten system prompts. Their evaluation method pairs each task with an environment, instructions and a checking script, examining resulting files and state as well as the final answer. They retain deterministic capability tests, repeat tasks because outcomes vary, and use a frozen smaller benchmark for faster iteration. The prompt and planning reductions were changes under consideration.[10][6]

In “Your harness, your memory”, published in April 2026, Chase recalled accidentally losing an internal email assistant. Recreating it from the same template did not restore its learned preferences: “I had to reteach it all my preferences, my tone, everything.” Building on an argument by Sarah Wooders, he argued that a harness’s control over context loading, compaction and cross-session state makes it central to memory ownership. He advocated open, model-agnostic harnesses to preserve control and model choice, while allowing that separate memory systems could become useful as abstractions mature.[8]

Chase’s August 2026 writing on managed agents separates three responsibilities: application context, tools and instructions; the harness; and production infrastructure. He described deliberately representing Fleet agents as files, using standards such as AGENTS.md, skills and MCP to make them portable back to code. Developer requests for custom middleware, coded tools and programmatic creation helped shape Managed Deep Agents. He argues that bundling the harness with durable execution, sandboxes and streaming will make production agents easier to build, while developers continue supplying their own business logic.[9]