Reflections on Three Years of Building LangChain

by Harrison Chase

Almost exactly 3 years ago, I pushed the first lines of code to langchain as an open source package. There was no company at the time, and no grand plan for what the project would become.

A month later, ChatGPT launched, and everything for langchain changed. It quickly gained steam as the default way to build your own LLM-powered apps. Over the past three years the industry has matured past prototyping chatbots toward productionizing agents that do things, and langchain has evolved into LangChain, the company.

Our product offerings have expanded, too: from a single Python open source package to a multi-language agent ecosystem consisting of multiple popular open source packages and a separate commercial platform (LangSmith). Our technologies power leading companies' agents like Rippling, Vanta, Cloudflare, Replit, Harvey, and thousands more.

Today, we’re announcing a $125 million funding round at a $1.25 billion valuation to continue that trajectory, expand LangSmith, the platform for agent engineering, and grow our open source contributions. We wrote more about our vision for LangSmith and what else we’re launching today in our announcement blog.

With such a large funding announcement (and on the eve of the third anniversary of the initial langchain launch), I also want to take the time to share my perspective on how agents have evolved over the past three years, how we’ve kept pace, worked to address fair feedback on the original langchain, and where the company is headed. 

Starting as a side project

langchain was launched as a single (800 line long?) python package in fall of 2022 out of my personal github hwchase17. It was a side project. I was inspired by going to meetups and running into a few folks on the bleeding edge, building some experimental stuff with language models. I was instantly fascinated by the technology but cannot claim to have had any idea how big LLMs would become. I saw a few common patterns in terms of how people were building and put those patterns into langchain. 

After the initial launch, I kept on iterating on it, adding mainly two things: (1) more integrations to various LLMs, vector DBs, etc; (2) more high-level “templates” for getting started with RAG, SQL question answering, extraction, etc in 5 lines of code. A lot of langchain in the early days was experimenting with prompting techniques, and we were figuring things out alongside everyone else building in the space. 

In addition to needing lots of integrations, it was clear from the beginning that there would be lots of options for LLMs. Especially in a dynamic industry, helping users pick a model and later change that decision was incredibly important. Model neutrality still remains one the main benefits of our products.

Forming a company

As the space (and langchain) exploded, I started working more closely with Ankush, my cofounder (and a much better engineer than me). We started to get the inklings of what would drive us to start a company and that early inspiration is still what we're focused on today:

LLMs are this great, transformational new technology. They are even more powerful when connected to external data and APIs. We call these systems agents. And it turns out building reliable agents is quite hard! When there is so much promise, but it’s difficult to realize the vision, there's a massive opportunity to help. We were (and still are) determined to build the best tools to help others build reliable agents. We know what some of the needed tools are, and we don’t yet know what others will be. Our goal is to figure out what the agents of the future look like, and then build tools to help make them real.

We started the company in February 2023 knowing that langchain was just the first tool we would build.

Launching LangSmith

The biggest problem we saw facing developers was that these LLM systems had quality problems. LLM calls kept on messing up, largely because they had the wrong context. In order to make them more reliable, you needed observability into the context going into the LLMs, and a way to test that once you modified that context it actually led to improvements.

LangSmith was our answer to this problem – observability and evals for LLM systems, and we went live with a beta in summer of 2023. Notably, we made LangSmith completely separate from langchain. We recognized that the space was very early and that a tool like LangSmith was much needed, so we committed to building LangSmith to be best-in-class, regardless of the framework (or lack of framework) that a developer used. LangSmith is neutral to the LLM and neutral to the underlying framework, adding to our open and composable philosophy of tooling.

Launching LangGraph

Around the summer of 2023, we started to get a lot of negative feedback about langchain. Some problems we could fix: like preventing breaking changes, making hidden prompts explicit, package bloat, dependency conflicts, outdated documentation. But one piece of feedback was harder to address – people wanted more control. While langchain was the fastest place to get started, we traded power for ease of use. The same high level interfaces in langchain that made it easy to get started were now getting in the way when people tried to customize them to go to production.

We started developing LangGraph that summer, and launched it in early 2024. There were two main pillars we focused on:

1. Controllability: no hidden prompts, no hidden context engineering. You had full control over your system - whether it was a workflow or agent or anything in between.
2. Runtime: we took everything we learned about what was needed for a production runtime (streaming, statefulness, human-in-the-loop, durable execution) and built it into LangGraph in a first-party way.

LangGraph was inspired by the limitations of the initial langchain. The production validation from companies like LinkedIn, Uber, J.P. Morgan, and BlackRock gave us confidence we were building in the right direction.

Revisiting LangChain

A few months ago, we decided to revisit langchain from the ground up. While we were seeing tremendous adoption of LangGraph, it did have a higher learning curve, and the incredible, persistent enthusiasm for langchain encouraged us that there was still a need in the industry that langchain was fulfilling. We had three goals for reimagined langchain:

1. Make it as easy as possible to get started building agents
2. Allow for more customization than we had previously
3. Give it a production-ready runtime

We knew this approach would require massive breaking changes to langchain. We decided it would be best to do this in 1.0 release. We accomplished our goals by:

1. Focusing on the core tool-calling loop that is now synonymous with "agents".
2. Adding in a new concept of middleware, which is uniquely designed to give developers control over the “context engineering” lifecycle exactly where they need it.
3. Building upon LangGraph, a runtime that supported streaming, durable execution, human-in-the loop, and more.

We believe langchain 1.0, released today, solves the goals we had for it, and importantly gives the community of over a million developers a clearer view of what we stand behind. The best patterns for an agent architecture are far better understood today than when we started the project, and 1.0 is far more curated than anything you’ve seen from our team before. Plus, we shipped a new centralized docs site which has been a long time coming! We hear you.

For the millions of developers (80 million monthly downloads!) using langchain today, we’re also keeping around langchain 0.x as langchain-classic, and are committed to supporting it for an extended period of time.

Evolving LangSmith into the Agent Engineering Platform

The bread and butter of LangSmith has been observability and evaluations, but that’s not the only tooling needed to build reliable agents. We started experimenting with bringing more functionality into the platform with “LangGraph Platform,” which was focused on deployments. As we look to the future, we see a number of new ways that we can help customers, and we want to make LangSmith a single place where you can get most of your tooling to build reliable agents. Today we’re bringing deployments into LangSmith, and are setting LangSmith up to be the comprehensive agent engineering platform. We will add other product lines in LangSmith in the future and aim to make each new product independent of the existing ones but well integrated into the platform.

Agents of the future

Our goal is to figure out what the agents of the future look like and build tools to facilitate that. We know what some of those pieces are (an agent runtime like LangGraph, observability, evals). We have some hunches about what the other pieces are that we are actively exploring. We also fully expect that there will be other components that, at this moment in time, we can't imagine what they'll look like – which makes this journey incredibly fun and rewarding for what we expect to be a long time.

If you have feedback on how our tools can adapt to better build the agents of the future, let me know on X. I appreciate every piece of feedback because we know our products will have to evolve.

If you need a partner when building the agents of the future - get in touch. We are lucky enough to work with wonderful companies like Vanta, Rippling, Replit, Clay, Cisco, Workday, and many more, and would love to work with more teams pushing what's possible.

If you want to help us on our mission in building the agents of the future - we’re hiring for basically all roles.