What Is LangChain? History, Release Dates & Roadmap (2026)

In October 2022, a machine learning engineer named Harrison Chase pushed a side project to GitHub. At work, Chase kept solving the same frustrating problem: connecting large language models to external data and tools meant writing the same boilerplate code, over and over, for every new application. The fix was a composable Python library that turned LLM pipelines into chains of modular, reusable components.

Chase called it LangChain.

Within eight weeks, it was one of the fastest-growing repositories on GitHub. Within six months, Benchmark had led a $10 million seed round and Sequoia was reported to be leading the next one. Three years later, LangChain was a $1.25 billion company whose core package is downloaded more than 175 million times a month, and the ideas it popularized (chains, then graphs, then harnesses) had become the vocabulary of an entire industry.

This is the complete story, with every release date, from that first commit to the multi-agent era of 2026: every pivot, every funding round, every framework that grew in LangChain's shadow, the infrastructure bet Chase says the company got wrong, and where LangChain is heading next.

TL;DR: LangChain launched in October 2022, five weeks before ChatGPT, and became the standard toolkit for building on language models. LangGraph followed in January 2024, Deep Agents in July 2025, and LangChain 1.0 on October 22, 2025. The company has raised about $160M at a $1.25B valuation, and the repo has ~147K GitHub stars. Build agents without code →

When Was LangChain Released? Every Release Date (2022–2026)

LangChain was released in October 2022. Harrison Chase created the GitHub repository on October 17, 2022 and published version 0.0.1 to PyPI on October 25, 2022. LangGraph followed on January 8, 2024, Deep Agents on July 29, 2025, and LangChain 1.0 and LangGraph 1.0 reached general availability together on October 22, 2025.

Last updated: September 2026. Refreshed for LangChain 1.0, Deep Agents, the $1.25B Series B, the 2026 LangSmith platform (Fleet, Sandboxes, Engine, LLM Gateway), and Harrison Chase's September 2026 account of the infrastructure bet LangChain got wrong. GitHub and PyPI figures were read on September 22, 2026.

LangChain at a Glance (2026)

The loop every framework in this story is built to run: plan, call a tool, check the result, repeat. In Taskade you get that loop without writing the framework.

What Is LangChain?

LangChain is an open-source framework for building applications and agents powered by large language models. Its core idea: LLMs are most useful when connected to the outside world, to your documents, your databases, your APIs, your tools. LangChain provides the connective tissue. In 2026 the name covers a three-layer stack: LangChain is the framework (integrations plus a standard agent), LangGraph is the runtime (durable, stateful execution), and Deep Agents is the harness (planning, sub-agents, a file system, and memory, ready to run).

Before LangChain, building an LLM application that could answer questions about your company's internal documents required writing custom code to:

1. Load the documents from S3, Notion, or a database
2. Split them into chunks that fit in the model's context window
3. Embed those chunks as vectors and store them in a vector database
4. When a user asks a question, embed the question, retrieve the most relevant chunks
5. Inject those chunks into the prompt alongside the question
6. Call the LLM API with the formatted prompt
7. Parse and return the response

Every team was writing this same seven-step pipeline from scratch. LangChain turned each step into a composable building block, document loaders, text splitters, embedding models, vector stores, retrievers, prompt templates, LLM wrappers, output parsers, and let you connect them with a few lines of code.

This pattern, Retrieval-Augmented Generation, or RAG, became the dominant enterprise AI architecture of 2023. LangChain didn't invent RAG, but it made RAG accessible to every developer with a Python interpreter. For a complete picture of how agents use external knowledge, see our AI agents guide and the Taskade agent tools reference.

Harrison Chase: The Founding Story

Harrison Chase studied statistics and computer science at Harvard, graduating in 2017. Chase then joined Kensho, a fintech startup later acquired by S&P Global, and led its entity-linking team, before moving to Robust Intelligence, a company that tested machine learning models for failures before they reached production. Both jobs were about the same unglamorous question, whether a model behaves reliably outside a demo, and they gave Chase a front-row seat to how fragile model-powered systems could be when they were not properly structured.

Chase kept running into the same problem: connecting a language model to external data was tedious, repetitive work. There was no standard way to load documents, no clean interface for vector stores, no composable pattern for combining retrieval with generation. Every project started from scratch. This problem, building reliable agentic workflows that connected LLMs to real data, would define the next two years of AI infrastructure development.

In the fall of 2022, Chase started building a library to fix this, at first for personal use. The repository went up on GitHub on October 17, 2022, and version 0.0.1 reached PyPI on October 25, 2022, with a simple README and a handful of integrations.

The timing was extraordinary.

About five weeks later, OpenAI launched ChatGPT on November 30, 2022, and the world's developer community collectively discovered they needed exactly what LangChain had just shipped.

The GitHub Explosion: Zero to 50,000 Stars in Record Time

When ChatGPT launched, millions of developers immediately started asking: How do I build something like this on my own data? LangChain was the answer sitting at the top of a Google search.

The growth was unlike anything the open-source community had seen:

By the spring of 2023, LangChain had passed 50,000 GitHub stars, one of the fastest climbs any developer library had ever made. The download curve kept going long after the hype cycle cooled: in September 2026 the langchain package alone is downloaded about 175 million times a month from PyPI, and langchain-core, the shared interface layer, about 146 million.

The community wasn't just starring it. They were building with it. The LangChain Discord went from zero to tens of thousands of members in a matter of weeks. Hundreds of tutorials, YouTube videos, and blog posts appeared daily. Enterprise teams at Fortune 500 companies were integrating it into production systems.

The pull requests kept coming faster than the small team could review them.

The second chart is the more honest measure of adoption. Stars measure attention; downloads measure installs, and most of those installs come from automated pipelines and production deployments rather than people browsing GitHub.

The Funding Rounds: From Side Project to a $1.25 Billion Company

LangChain has announced about $160 million across three rounds: a $10 million seed led by Benchmark in April 2023, a $25 million Series A led by Sequoia Capital, and a $125 million Series B led by IVP on October 20, 2025 at a $1.25 billion valuation. Each round landed on a product inflection: the viral library, the observability platform, and the agent platform.

Seed Round: April 2023

Benchmark, one of Silicon Valley's most storied venture firms, led a $10 million seed round, which LangChain announced on April 4, 2023. At this point LangChain had no revenue and no commercial product, just an open-source library that had gone viral and a founding team that had only just incorporated.

Series A: Reported April 2023, Announced February 2024

Days after the seed, Business Insider reported that Sequoia Capital was leading a round that valued LangChain at at least $200 million. LangChain did not formally announce that round until February 15, 2024, when it disclosed a $25 million Series A led by Sequoia in the same post that took LangSmith to general availability. That split is why sources disagree on the Series A date: the money was reported in 2023, and the announcement came in 2024.

The Series A thesis was the "picks and shovels" bet of the AI gold rush: if the market for LLM applications was going to be enormous, the tooling layer every team used to build them would capture real value.

Series B: October 2025

On October 20, 2025, LangChain announced a $125 million round at a $1.25 billion valuation, led by IVP. Existing investors Sequoia, Benchmark, and Amplify returned, CapitalG and Sapphire Ventures joined, and so did the venture arms of ServiceNow, Workday, Cisco, Datadog, and Databricks. At the time LangChain said its open-source packages had a combined 90 million monthly downloads and that 35 percent of the Fortune 500 used its services. The round closed two days before LangChain 1.0 shipped.

A note on the numbers: some trackers list a separate "$100 million Series B" from July 2025. That figure comes from press reports while the round was still being raised. LangChain's own October 2025 announcement is the round of record, and it is the one counted here.

The Chain Era: What LangChain Originally Was

Understanding LangChain's evolution requires understanding what the "chain" abstraction actually was, and why it both worked brilliantly and eventually hit its limits.

A chain in early LangChain was a sequence of operations connected by their inputs and outputs:

Step 1: Load documents → Step 2: Split into chunks → Step 3: Embed chunks
→ Step 4: Store in vector DB → Step 5: Retrieve relevant chunks
→ Step 6: Format prompt → Step 7: Call LLM → Step 8: Parse output

Each step's output became the next step's input. The whole thing could be serialized to JSON, loaded from a config file, and run repeatedly. It was elegant for the RAG use case.

LangChain shipped over a dozen chain types for common patterns:

• LLMChain, the simplest: prompt template + LLM + output parser
• SequentialChain, chain multiple LLMs together in sequence
• RetrievalQA, the canonical RAG chain: retrieve + generate
• ConversationalChain, add memory to an LLM conversation
• MapReduceChain, split a large document, summarize each part, reduce to one answer
• RouterChain, route to different sub-chains based on input

The library also shipped hundreds of integrations, connections to OpenAI, Anthropic, Cohere, Google, 50+ vector stores (Pinecone, Chroma, Weaviate, pgvector), dozens of document loaders (PDF, Notion, Google Drive, GitHub, Confluence), and output parsers for JSON, CSV, and custom schemas.

This breadth of integrations was a key competitive moat. Building your RAG pipeline meant choosing your pieces (OpenAI for embeddings, Pinecone for storage, Anthropic for generation), LangChain connected all of them with a consistent interface.

The Limits of Chains: Why Agents Needed Something New

Chains worked beautifully for predictable pipelines. They broke down when you needed AI that could decide what to do next.

Consider a research assistant agent. You ask it: "Compare the revenue growth of Apple and Microsoft for the last three years and tell me which is a better investment."

A chain can't handle this. The agent needs to:

1. Search for Apple's revenue data (tool use)
2. Search for Microsoft's revenue data (tool use)
3. Decide if it has enough data or needs to search more
4. Calculate growth rates (tool use or reasoning)
5. Synthesize a recommendation
6. Maybe search for analyst opinions to support it
7. Return a final answer

The number of steps isn't known at build time. The agent might need to loop, decide to search again if the first result was irrelevant. It needs state, what has it already found? It needs error handling, what if a search fails?

LangChain's original AgentExecutor tried to handle this but had critical weaknesses. Understanding these limitations is why agentic engineering emerged as a discipline rather than just a collection of libraries:

• No persistent state: state was squeezed into the conversation history, causing context pollution
• No cycle control: a runaway agent could loop indefinitely
• No partial execution: if step 4 of 7 failed, you started over from scratch
• No human-in-the-loop: you couldn't pause execution for human approval and resume
• No sub-agent coordination: one agent doing everything was the only pattern

These weren't bugs in LangChain. They were architectural limits of the chain/agent paradigm. The real question was whether the right fix was a better AgentExecutor or a different abstraction entirely.

The answer turned out to be a graph.

LangGraph: The Stateful Multi-Agent Pivot

In January 2024, the LangChain team released LangGraph, a library for building stateful, cyclic, multi-actor applications with LLMs.

The core insight was simple: instead of a linear chain, use a directed graph.

• Nodes are units of work (call an LLM, run a tool, check a condition)
• Edges define routing (always go to node B after node A, or conditionally route to B or C based on A's output)
• State is a typed Python TypedDict that flows through the graph, every node reads from state and writes back to state
• Cycles are explicitly supported. You can loop back to an earlier node when needed

This might look like the same loop as AgentExecutor. What's different is state:

Every call to the Agent node reads from and writes to a shared State object, a typed Python dict with explicit fields like messages, documents_found, current_plan, tool_results. Nothing is hidden in conversation history. Every node knows exactly what state the graph is in. Debugging means reading the state snapshot, not reconstructing conversation flow.

LangGraph also added checkpointing, save the graph's state to disk (SQLite or Redis by default) and resume from any checkpoint. A long-running research agent that crashes halfway through can resume from the last saved state. Human-in-the-loop becomes straightforward: pause the graph, surface the state for human review, resume with updated state.

LangGraph's Multi-Agent Architecture

For multi-agent systems, LangGraph introduced the Supervisor pattern, a design that maps directly to how Taskade's AI teams coordinate across tasks:

A Supervisor node (powered by an LLM) decides which specialist agent to delegate to. Each agent is itself a node in the graph. It can have its own tools, its own memory, its own state writes. Agents communicate via the shared graph state, not by calling each other directly. The Supervisor routes based on what each agent returns.

This pattern maps onto real organizational structures: a project manager (Supervisor) delegates to specialists (Researcher, Writer, Coder, QA) based on what work remains, reviews their output, and routes to the next step. The graph is the org chart made executable.

LangSmith: The Commercial Product

While LangChain and LangGraph were always open-source, LangChain Inc needed a commercial product to build a sustainable business. That product is LangSmith.

LangSmith launched in closed beta in July 2023 and reached general availability on February 15, 2024, in the same announcement as the Series A. At launch LangChain reported more than 80,000 signups, more than 5,000 monthly active teams, and more than 40 million traces logged in January 2024 alone. It provides:

• Tracing: every LLM call, every tool invocation, every node execution is logged with full input/output and timing
• Evaluation: run automated evals against your chains and agents to measure accuracy, coherence, and task completion
• Dataset management: collect production traces and curate them into evaluation datasets
• Production monitoring: track latency, error rates, and cost trends over time
• Prompt versioning: version-control your prompts alongside your code

The business model is pure developer infrastructure: LangSmith is free for small volumes (useful for getting started), and paid plans scale with usage. Enterprise contracts include SSO, VPC deployment, and SLA guarantees.

LangSmith fills the observability gap that makes the difference between "I built a demo that works in my dev environment" and "I have a production system I can trust and debug when it fails." This gap is real, most teams that built LangChain pipelines in 2023 discovered quickly that production LLM systems fail in unexpected ways, and you can't fix what you can't observe. The same principle applies to Taskade Genesis automation workflows: visibility into every step is what separates demos from production systems.

The AI Agent Framework Ecosystem

LangChain's success created a generation of frameworks built in its shadow, some on top of it, some in reaction to its limitations, and some targeting entirely different developer audiences.

LlamaIndex (November 2022)

Released just weeks after LangChain, LlamaIndex (originally GPT Index) was built by Jerry Liu specifically for the RAG use case, ingesting, indexing, and querying data with LLMs. While LangChain went broad (agents, tools, chains, memory), LlamaIndex went deep on data, specialized loaders for 100+ data sources, advanced retrieval strategies (hybrid search, reranking, parent-child chunking), and query engine abstractions. The two frameworks are often used together rather than competitively.

AutoGen: Microsoft (September 2023)

Microsoft Research released AutoGen in September 2023 as a framework for multi-agent conversation. The core concept: agents are conversational entities that exchange messages to solve problems. A UserProxy agent talks to an AssistantAgent; the AssistantAgent might spawn SubAgents. Code is executed, results flow back as messages, and the conversation continues until a task is complete. AutoGen's message-passing model is intuitive but can make complex state management difficult, something LangGraph's typed state solves more explicitly.

In October 2025 Microsoft folded AutoGen and Semantic Kernel into a single successor, Microsoft Agent Framework, which reached version 1.0 in April 2026. AutoGen itself is now in maintenance mode, taking bug fixes and security patches but no new features.

CrewAI (November 2023)

João Moura, a Brazilian software engineer, released CrewAI in late 2023: the repository dates to October 27, 2023, and the first PyPI release to November 14, 2023. CrewAI started on LangChain components and was later rebuilt as a standalone framework with no LangChain dependency. It introduced a higher-level abstraction: instead of defining nodes and edges, you define Crew members with roles, goals, and backstories. The crew mental model, multiple specialized agents collaborating on tasks, proved immediately intuitive for developers. A crew might have a Researcher agent, a Writer agent, and an Editor agent, each with a specific role and the tools appropriate to that role. The Crew orchestrates them through tasks and handles the routing automatically.

CrewAI's opinionated structure made it dramatically easier to get started with multi-agent systems. It became one of the fastest-growing AI frameworks on GitHub and passed 58,000 stars by September 2026, with a 1.0 release in October 2025.

Mastra (TypeScript, 2024–2025)

As the LangChain ecosystem matured in Python, a gap remained in the TypeScript world. While langchain.js existed, TypeScript teams found it felt like a port rather than a native design.

Mastra emerged as a TypeScript-first alternative. Its distinguishing features, demonstrated concretely in Damian Galarza's June 2026 tutorial on where the agent loop should stop and the workflow should start, include:

• Typed workflow steps using Zod schemas for both input and output
• Multi-model decomposition: different models for different steps (a small local model for classification, a larger model for scoring)
• Built-in evals attached to individual steps, not bolted on at the end
• setState / getStepResult for state management without threading context through function arguments
• Mastra Studio, a local dev UI for visualizing workflow DAGs, running fixtures, and inspecting step-by-step execution

The Mastra pattern explicitly forces a decision at every step: should this be a model call or deterministic code? That discipline, separating what the LLM needs to do from what code can do reliably, produces systems that are cheaper, faster, and more debuggable than single-agent solutions. For teams who want this discipline without framework overhead, Taskade's automation triggers and agent tools apply the same separation through a visual interface.

LangChain vs The Framework Field: A Full Comparison

Star counts read from GitHub on September 22, 2026 and rounded.

The Criticisms: When "Just Use LangChain" Wasn't Enough

No technology grows this fast without accumulating critics. By mid-2023, a counter-narrative was forming: LangChain is too complex, too abstract, and too hard to debug.

The criticisms were real and came from experienced engineers:

1. The Abstraction Rot Problem

LangChain's chain abstraction hid too much. When an LLMChain failed, the error might be in the prompt template, the model API call, the output parser, or the data flowing between them. But the abstraction gave you a cryptic error from a layer you didn't fully understand. Debugging required reading LangChain source code, not just your own.

This was the classic trade-off of good abstractions: they accelerate the common case but make the edge cases harder. For RAG on well-structured documents, LangChain was excellent. For complex, multi-step agents with error recovery, the abstraction became an obstacle.

2. Too Many Dependencies, Too Many Imports

Early LangChain required installing the entire library to use any feature. The pip install langchain was enormous, pulling in dozens of dependencies even if you only needed one integration. The library split into langchain-core, langchain-community, and provider-specific packages (like langchain-openai, langchain-anthropic) in 2024, largely solving this. But the damage to the library's reputation for bloat was already done.

3. API Instability in 2023

In 2023, LangChain was shipping changes so fast that tutorials became outdated within weeks. Developers investing in LangChain would find their code broken by a minor version update. This is an inherent tension in early open-source projects, move fast to capture community, or move carefully to protect early adopters, and the LangChain team initially prioritized speed.

LangChain v0.1, released in January 2024 alongside the first LangGraph release, represented a deliberate shift: a stable public API with deprecation warnings before breaking changes. LangChain 1.0 went further in October 2025: legacy chains moved to a separate langchain-classic package, and LangGraph committed to no breaking changes until version 2.0.

4. The "Just Use the SDK" Critique

By 2024, a legitimate alternative emerged: just call the LLM provider's API directly with structured outputs and tool calls. OpenAI's function calling (June 2023) and Anthropic's tool use API gave developers native ways to build agents without an abstraction layer. Many engineers concluded that for simple agents, the overhead of learning LangChain's abstractions wasn't worth it. You'd end up with less code and better debuggability by working directly with the SDK.

The LangChain team's response was pragmatic: LangGraph was explicitly designed for cases where the direct SDK approach breaks down, complex multi-agent workflows with cycles, state, and coordination. Use the raw SDK for simple cases. Use LangGraph when you need the graph.

The Chain → Agent → Graph Evolution: A Systems Design Lesson

LangChain's evolution from chains to agents to graphs is not just company history. It's a design lesson that applies to every AI system.

The pattern maps onto the insight at the center of Damian Galarza's June 2026 Mastra tutorial, which opens from the observation that most agent demos hand one model the entire job: stop giving one agent the whole job.

The same tension exists in every complex software system:

• Deterministic pipelines are fast and predictable but rigid. They can't adapt to unexpected inputs
• Pure LLM agents are flexible but expensive and opaque. You can't reason about what they'll do
• Typed workflow graphs are the synthesis: explicit structure where structure is known, LLM judgment where it's needed, typed state that makes the whole system inspectable

This is why Mastra's step-by-step approach, LangGraph's node/edge architecture, and the Claude Agent SDK's harness design all converge on the same pattern: be explicit about which parts should be model calls, which parts should be deterministic, and how the whole thing fits together.

The TypeScript Path: Mastra, LangChain.js, and the Node.js Ecosystem

The Python LangChain ecosystem had a JavaScript/TypeScript counterpart from early on, langchain.js. But the TypeScript AI framework story developed in a different direction.

langchain.js followed the Python conventions and was maintained by the same team, but TypeScript developers often found it felt like a translation rather than a native design. Type safety was inconsistent, and patterns like document loading and vector store connections often required workarounds for the Node.js environment.

The gap opened space for framework alternatives:

Mastra (released publicly in 2024-2025) takes a significantly different approach. Rather than adapting LangChain's chain/agent metaphor to TypeScript, Mastra starts from TypeScript's type system and asks: what would an AI workflow framework look like if designed natively for TypeScript from the ground up?

The answer is a workflow system where every step has a Zod-validated input schema, a Zod-validated output schema, and optionally a state schema, making the entire workflow type-safe end to end. Different models run at different steps (a small local model for cheap classification, a larger model for complex reasoning), and evals can be attached to individual steps rather than bolted on after the fact.

For teams building production TypeScript agents, this matters because:

1. Cost control: use Ministral 3.8B for email classification (milliseconds, pennies), Qwen 35B for scoring (seconds, more expensive), each in the right place
2. Testability: extract deterministic functions from steps, write unit tests against them before building the LLM wrapper
3. Observability: Mastra Studio renders the workflow DAG locally, shows step-by-step input/output, and records eval scores alongside traces

This TypeScript-native approach is part of a broader shift: as AI agent frameworks mature, the emphasis is moving from "connect everything to an LLM" toward "be explicit about what the LLM needs to do versus what deterministic code can do."

LangChain and the RAG Revolution

Before addressing what LangChain is today, it's worth documenting what it made possible in 2023: the RAG revolution that changed how enterprises deploy AI.

Before LangChain-style RAG, enterprise AI deployments had two options:

1. Fine-tuning: expensive, slow, requires ML expertise, and the model's knowledge was frozen at fine-tuning time
2. Prompt stuffing: putting all relevant text directly in the prompt, limited by context window size and expensive at scale

RAG offered a third path: index your documents once, retrieve the relevant ones at query time, and inject only the relevant context into the prompt. With LangChain providing the standard toolkit for this, the pattern spread rapidly.

Companies built internal knowledge bases where employees could query the company's Confluence, Notion, and email archives in natural language. Law firms built contract analysis tools. Healthcare companies built clinical decision support systems. Financial services firms built document review pipelines.

The key LangChain components that powered this:

This standardization was the key contribution: a developer who learned LangChain's interfaces could swap out any component, switch from OpenAI embeddings to Cohere, from Pinecone to pgvector, from GPT-4 to Claude, without changing their application logic.

LangGraph Platform, Studio, and Interrupt: The Road to Production (2024–2025)

LangGraph became a platform in three steps. LangGraph Cloud entered beta on June 27, 2024 as managed hosting for LangGraph agents. LangGraph Studio followed on August 1, 2024, billed as "the first agent IDE," with a visual graph, step-by-step state inspection, and the ability to edit state mid-run. On October 31, 2024, the hosting product was renamed LangGraph Platform and split into cloud, self-hosted, and bring-your-own-cloud options.

The platform reached general availability on May 14, 2025, announced at Interrupt, LangChain's first annual conference, which drew about 800 people to San Francisco. The same week, LangChain open-sourced Open Agent Platform, an early attempt at letting non-developers configure agents. In October 2025 the names changed once more: LangGraph Platform became LangSmith Deployment and LangGraph Studio became LangSmith Studio, folding everything commercial under the LangSmith brand.

Deep Agents: LangChain's Agent Harness (2025–2026)

Deep Agents is LangChain's open-source agent harness, first published to PyPI on July 29, 2025. It packages the patterns that made coding agents work (a planning tool, sub-agents with their own context windows, a file system the agent can read and write, memory, and skills) into an agent that is ready to run. LangChain built it after studying Claude Code, OpenAI's and Google's deep research agents, and Manus, and concluding they all do the same few things under the hood.

The name comes from the sub-agents. A deep agent can hand a focused task to a sub-agent with a clean context window, let it go deep, and receive back only the result. The file system does the rest of the context work: plans, notes, and large tool outputs live in files instead of in the conversation.

By September 2026 the deepagents repository had about 30,000 GitHub stars and the package about 5 million monthly downloads. At Interrupt 2026 LangChain added Managed Deep Agents, a hosted version, and shipped Deep Agents v0.6. For the wider idea behind it, see our agent harness explainer and the history of the agent harness.

LangChain 1.0 and LangGraph 1.0 (October 22, 2025)

LangChain 1.0 and LangGraph 1.0 reached general availability together on October 22, 2025, the first stable major versions in the project's three-year history. LangChain's own summary: "a thoughtful refinement that preserves what works while fixing what didn't."

What changed:

The release settled the vocabulary the whole stack uses today. In LangChain's words: "LangChain is the agent framework: the abstraction and integrations layer." "LangGraph is the agent runtime." "Deep Agents is an off-the-shelf agent harness," whose job "is to get the right context to the model at the right time."

Which layer to use follows directly from those definitions. Start with Deep Agents when you want a capable agent with context management already built in. Use LangChain when you want minimal abstraction and fine control over tools. Drop to LangGraph when you need a custom workflow that mixes deterministic and agentic steps.

LangSmith Becomes a Runtime: Fleet, Sandboxes, Engine, and the LLM Gateway (2025–2026)

Between October 2025 and July 2026, LangSmith grew from an observability tool into the runtime an agent lives in. Each new product answers a question a team hits after its first agent works:

Two of these deserve a closer look. Sandboxes give each agent a hardware-isolated microVM, and an auth proxy adds credentials to outbound requests at the network layer, so secrets never sit inside the sandbox. Engine closes the loop LangSmith was always built around: it watches production traces, clusters failures into named issues, diagnoses root causes against your code, and proposes fixes and eval coverage. For how sandboxes compare across the industry, see our guide to AI agent sandboxes.

A gateway decides which model serves each request and what the request is allowed to carry. In Taskade, Auto picks from 15+ frontier models from OpenAI, Anthropic, and open-weight providers for you.

The Infrastructure Bet Harrison Chase Got Wrong

Asked in a September 2026 interview on Browserbase's Navigators series what LangChain would do differently, Harrison Chase gave a specific answer: "I think we built a gateway way too late."

The team had discussed a model gateway a year or more earlier and passed, because it could not see what LangChain would add on top of existing options: "we just didn't really know like what we could provide that was different on top of like a LiteLLM or an OpenRouter." Two things Chase says the company "consistently underestimated" explain the miss:

1. The demand for inference. "Just the demand for just inference that is out there. Like it's massive."
2. General-purpose coding agents. "How big and general purpose coding agents would be. That market also massive."

The product LangChain eventually shipped answers the original question. The LLM Gateway's difference from a plain proxy is governance joined to observability: it enforces spend limits and detects sensitive data "before requests leave your environment," and every policy event lands in LangSmith beside the trace that triggered it.

The same conversation contains the clearest statement of how LangChain now decides what to build:

• The rule of three. When LangChain sees teams solve the same problem three times in slightly different ways, the pattern goes into Deep Agents. Chase's example is offloading large tool results: write the full response to the file system, show the model the first thousand characters, and let it read the rest on demand. "I think it's generally standard practice now, but wasn't like a year ago."
• Pick the architecture by domain. LangGraph stays popular for well-known processes where determinism matters, and Chase names financial services. But LangChain's own early deep-research example was built as a graph (plan, fan out, fan in, review) and has since moved to a harness, because "deep research is really just an agentic task."
• Put determinism back through middleware. Chase describes a "goal mode" check: when the agent thinks it is done, run a deterministic check against the goal, and send it back to the start if the check fails.
• A virtual file system first, a real sandbox when needed. Deep Agents ships a virtual file system so most agents never need a container. One customer still moved to a full sandbox, because its users wanted command-line tools that a mock cannot supply.
• Post-training is coming for the simple steps first. High-volume teams now post-train smaller models, "generally not to drive the core agentic loop but maybe for simpler things like classification or extraction," using the traces and evals LangSmith already collects.

The admission is useful beyond LangChain. Every team building on language models makes the same sequencing bet about which layer to own, and the layer that looks commoditized (a proxy in front of the model APIs) can turn out to be where cost control, safety, and observability meet.

LangChain Roadmap: Where LangChain Is Going in 2026 and Beyond

LangChain has not published a formal roadmap document, but its launches and Harrison Chase's public statements through 2026 point in one direction: from framework to agent engineering platform.

The events calendar says the same. After Interrupt 2026 in San Francisco on May 13–14, where most of the platform launches above were announced, LangChain added city editions in New York (September 24, 2026) and London (October 13, 2026).

For teams that want the destination without the framework, the same arc (memory, then intelligence, then execution) is what a Taskade Genesis workspace gives you from a single prompt.

Model Support: Model-Agnostic by Design

LangChain maintains first-class integrations with every major model provider and with open-weight models through local runtimes. That model-agnostic layer, swap one provider for another without rewriting your application, was LangChain's original value proposition, and LangChain 1.0's standard content blocks extend it to reasoning traces and citations. Since the model catalog changes every few months, check the LangChain integrations docs for the current list rather than any snapshot.

From LangChain to No-Code: The Taskade Genesis Path

LangChain made multi-agent AI accessible to Python developers. LangGraph made stateful workflows accessible to experienced ML engineers. Mastra made typed agent workflows accessible to TypeScript teams.

The next step in that accessibility progression, AI agent orchestration for everyone, without writing any framework code, is where platforms like Taskade Genesis enter the picture. This is the end of the vibe coding continuum: where natural language is the entire programming interface.

The parallel between LangGraph's design and Taskade's Workspace DNA architecture is not coincidental. Both emerged from the same insight: that the most powerful AI systems combine three distinct capabilities:

In Workspace DNA terms: Memory feeds Intelligence, Intelligence triggers Execution, Execution creates Memory. ▲ ■ ●

The difference is accessibility. Building a LangGraph application requires:

• Installing Python 3.10+, LangGraph, LangChain Core, and provider packages
• Understanding TypedDict state schemas
• Writing node functions and routing logic
• Setting up a vector store for memory
• Managing API keys for each model and integration
• Deploying the graph to a server

Building the equivalent in Taskade Genesis requires:

• Describing what you want in a prompt
• Connecting integrations through a visual interface
• Triggering automations through events (Slack message, form submission, schedule)
• Publishing your agent, done

See the Genesis complete guide for a full walkthrough of setting up multi-agent workflows, persistent memory, and 100+ integrations without code. For team-based orchestration, the AI teams guide covers coordinating multiple agents on complex tasks.

Both approaches use the same underlying pattern, stateful agents with tools, connected by routing logic, with persistent memory. The code path and the no-code path arrive at the same architecture.

What LangChain Got Right (And Why It Matters for Every AI Builder)

Whether you use LangChain directly or not, the framework's influence on how we think about AI system design is profound. Several patterns that LangChain established are now considered standard practice:

1. Model-agnostic interfaces. The idea that your application logic shouldn't be coupled to a specific model provider is now foundational. Swap OpenAI for Anthropic without rewriting your application. This is table stakes for any modern AI framework.

2. Retrieval as a first-class primitive. Before LangChain, RAG was a research technique. After LangChain, it's the standard pattern for enterprise AI. The document loader → splitter → embedder → vector store → retriever pipeline is now how most knowledge-intensive AI applications work.

3. Composable tool use. The idea that agents should have access to a well-defined set of tools, search, calculator, code interpreter, API calls, and that tools should have consistent schemas for how the model calls them, is now the basis for OpenAI's function calling, Anthropic's tool use, and every major agent framework. See how Taskade's built-in agent tools implement this same composable pattern without code.

4. Observability is not optional. LangSmith's existence and success made it clear that LLM applications need the same observability tooling as any production system, tracing, metrics, evaluation, and alerting. You can't run an AI product in production without seeing what's happening inside it.

5. State management requires explicit design. LangGraph's success with typed state made explicit what many teams learned the hard way: state that lives in a conversation history is hard to inspect, hard to test, and hard to recover from. Explicit, typed, checkpointed state is the production-grade solution.

These five insights should inform how you design AI systems, regardless of which framework (or no framework) you use.

Conclusion: The Framework That Changed Everything

Harrison Chase's October 2022 GitHub commit changed how an industry builds software. The chain abstraction it popularized wasn't perfect, and it couldn't survive contact with production-scale agents. But it established the vocabulary, the integrations, and the community that made the AI agent era possible.

The rest of the story is a series of honest corrections. LangGraph answered the limits of chains with explicit state. Deep Agents answered the limits of hand-built graphs with a ready-made harness. LangChain 1.0 answered the instability critique with a stable API. And the 2026 LangSmith platform (sandboxes, a gateway, and an agent that debugs agents) answers the question every team hits after its first agent works: where does this thing run, and who keeps it safe and affordable? Chase's own verdict on the gateway may be the most useful lesson in the whole history. The layer that looks like a commodity can turn out to be the one that matters.

CrewAI, Microsoft Agent Framework, Mastra, and the rest are the ecosystem that flourished in LangChain's wake.

And the no-code path, Taskade Genesis, with its 150,000+ apps built from prompts, represents the next step in accessibility: multi-agent AI for everyone, not just developers who know Python. Whether you're building AI agents faster with code or building them without code through Taskade Genesis, the destination is the same: AI systems that remember, reason, and execute on your behalf. Explore the Community Gallery or browse AI agent templates to see what others have built.

The chain that Chase started in October 2022 hasn't ended. It became a graph, and then a harness. ▲ ■ ●

Frequently Asked Questions