Harrison Chase

Harrison Chase is the co-founder and chief executive of LangChain, and the creator of the open-source framework from which the company grew. His work packages the engineering around a language model: connecting it to data and tools, coordinating its actions, and inspecting the inputs and decisions behind its results. As developers moved from experiments to deployed agents, he and the LangChain team reconsidered how much those frameworks should do for developers—and how much they should expose for customization.

Based in San Francisco, Harrison previously worked as a machine-learning engineer at Kensho Technologies from July 2017 to October 2019, then at Robust Intelligence from October 2019 to January 2023. His career history spans those roles; the immediate inspiration for LangChain came from meeting developers experimenting with language models and recognizing application patterns they were repeatedly assembling themselves.

When the shortcut became the obstacle

Harrison released LangChain as a Python side project in October 2022. He packaged integrations with models and data systems, then added templates for tasks such as retrieval-augmented generation, SQL question answering, and extraction. ChatGPT’s launch the following month accelerated interest. He and Ankush Gola started the company in February 2023.

The early framework made experimentation accessible, but its high-level interfaces could obstruct customization when applications moved toward production. In his three-year retrospective, Harrison acknowledged hidden prompts, dependency conflicts, breaking changes, and outdated documentation. Some problems could be fixed within the existing package; developers’ demand for more control required a different design.

The team began developing LangGraph in summer 2023 and launched it in early 2024. It exposed decisions about prompts, context, and execution while providing a runtime for streaming, stateful operation, durable execution, and human intervention. Developers could prescribe a workflow, let a model choose actions, or combine the two.

That introduced another tradeoff: LangGraph offered more control but required more learning. Developers still wanted an easy starting point. The team’s LangChain 1.0, released in October 2025, focused on the core tool-calling loop, added middleware for customizing how context reaches the model, and used LangGraph as its runtime. The company announced $125 million in financing at a $1.25 billion valuation alongside the release. Harrison’s account preserves the reason for both designs: shortcuts help developers begin, but must leave room to change the behavior that matters to their application.

Context, execution, and evidence of improvement

Harrison’s 2023 account of context-aware applications distinguished several jobs often grouped together as prompting. Instructions specify behavior; examples demonstrate tone or output formats; retrieval supplies facts for an answer; fine-tuning changes model weights. Getting that information into an application also requires data engineering: loading documents, transforming them, selecting relevant material, and inspecting the prompt that finally reaches the model.

That last step explains the need for LangSmith, which entered beta in summer 2023. A retrieved document may be relevant but poorly formatted, or a later model call may receive a different combination of instructions, history, and tool results than the developer expects. Traces let developers inspect those intermediate inputs rather than diagnose an application solely from its final answer. The team built LangSmith independently of LangChain and the chosen model, so developers could use it with other frameworks or their own code.

Two further positions connect Harrison’s tooling to his advice for builders:

• Prescribe required steps in code. Harrison argues for workflows alongside agents. A model can choose a tool or react to an unexpected input while code ensures that a mandatory step follows. An architecture in which agent A always hands work to agent B already combines model-directed work with a fixed sequence. LangGraph accommodates that mixture rather than requiring developers to choose between complete prescription and complete discretion.

• Build evaluation cases before trusting a demonstration. Language models allow a working prototype without a training dataset, but that convenience leaves developers with few examples for testing changes. Harrison recommends assembling cases from hand labeling, production traffic, or generated data, then combining model-assisted evaluation with user feedback. He also values traces and benchmarks as a way to show enterprise reviewers what an agent does and where it fails. Inspection explains a run; evaluation tests whether changes improve results.

Substantial delegation with human intervention

Harrison’s enterprise-agent framework weighs the value of successful work against the probability and cost of failure, as well as operating cost. He credits a conversation with Assaf, Monday’s head of AI and the author of GPT-Researcher, as an important influence on that framing.

The useful design question is how much work an agent can accomplish before a person needs to intervene. A research report can remain a draft for review; a code change can stay on a branch and be reverted. These patterns let the agent produce something substantial while reserving consequential decisions for a person. Approval at every tiny step would consume much of the benefit of delegation.

Harrison built an email agent to explore ambient agents, which begin work in response to events rather than a person opening a chat. Incoming email can trigger background work, while outgoing replies or calendar actions can require approval. An Agent Inbox gathers actions needing attention. Users can edit a proposed tool call, answer a clarifying question, or return to an earlier execution state and resume with a correction. Event-triggered work allows several tasks to progress concurrently, making the interface for intervention part of the agent’s design.

From longer tasks to owned memory

Harrison also explored what a simple model-and-tool loop was missing when asked to sustain longer tasks. He built the initial Deep Agents package over a weekend, describing it in July 2025 as a combination of planning, subagents, detailed instructions, and a state-backed virtual filesystem. Planning helps organize a task into steps; stored intermediate notes give the agent somewhere to keep information as the work proceeds. This extended his work from coordinating execution to supplying the scaffolding an agent needs to carry a larger assignment through.

Harrison’s concern with agent memory ownership gained a concrete example when his internal email assistant was accidentally deleted. Recreating it from the same template did not restore the preferences and tone it had accumulated. He had to teach those again.

In Your harness, your memory, he argues that the harness—the software coordinating a model, tools, context, and state—determines how an agent reads, updates, and preserves memory. He credits Sarah Wooders’s explanation of memory as a core responsibility of that software. Moving these functions behind proprietary APIs, he argues, can make accumulated knowledge difficult to carry between models or platforms.

Harrison presents Deep Agents, LangChain’s open-source, model-agnostic harness, as a way for builders to control that knowledge, including through their own memory stores and deployment infrastructure. His position leaves room for change: separate memory systems may become more practical once the field develops clearer conventions. For now, his email-assistant experience supplies the stakes of the argument. Replacing the starting software was easy; replacing what the agent had learned was not.