LangChain
Last reviewed
Jun 2, 2026
Sources
No citations yet
Review status
Needs citations
Revision
v8 ยท 6,815 words
Improve this article
Add missing citations, update stale details, or suggest a clearer explanation.
Suggest edit
CtrlK
Last reviewed
Jun 2, 2026
Sources
No citations yet
Review status
Needs citations
Revision
v8 ยท 6,815 words
Add missing citations, update stale details, or suggest a clearer explanation.
See also: Prompt engineering and Retrieval-augmented generation
LangChain is an open-source framework designed for building applications powered by large language models (LLMs). Available as both a Python and TypeScript package, the framework provides developers with modular components, pre-built chains, and agent architectures that simplify the process of connecting language models to external data sources, APIs, and tools. LangChain enables data-aware and agentic applications that can reason over private data, call external services, and interact dynamically with their environment.[1]
Since its initial release in October 2022, LangChain has grown from a single Python library into a comprehensive platform for agent engineering. The project has accumulated over 130,000 GitHub stars across its ecosystem and is widely regarded as one of the most influential open-source projects in the artificial intelligence space.[2] By the time of the Series B announcement in October 2025, the combined Python and JavaScript packages were averaging roughly 90 million downloads per month, and PyPI tracking data through mid-2026 shows the Python distribution alone exceeding 230 million monthly downloads at peak.[3][4]
LangChain was created by Harrison Chase and Ankush Gola. Chase studied statistics and computer science at Harvard University, graduating in 2017. After college, he joined Kensho Technologies, a fintech startup later acquired by S&P Global, where he led the entity linking team. He then served as Head of Machine Learning at Robust Intelligence, a startup focused on AI safety and model validation. These experiences exposed him to the inefficiencies in AI development pipelines and directly inspired the creation of LangChain.[5][6]
Ankush Gola holds a B.S.E. in Electrical Engineering from Princeton University. Before co-founding LangChain, he worked as a software engineer at Facebook (now Meta) on mobile and data infrastructure, and later as a Technology Lead Software Engineer at Robust Intelligence, where he and Chase first worked together.[7]
Chase initially developed the LangChain project in October 2022 while still at Robust Intelligence. The framework was released as an open-source project and quickly gained traction among developers building LLM-powered applications. By early 2023, Chase and Gola incorporated LangChain, Inc., headquartered in San Francisco, California.[5]
LangChain's rapid adoption attracted significant venture capital interest. The company raised a seed round of approximately $10 million from Benchmark in April 2023, with the deal coming together within days of the open-source project's initial traction. Less than a year later, in February 2024, LangChain closed a $25 million Series A led by Sequoia Capital, valuing the company at approximately $200 million. The Series A enabled the company to scale its commercial efforts around LangSmith and shift focus from individual developers to enterprise customers.[5][8]
In October 2025, LangChain announced a $125 million Series B funding round led by IVP (with the deal led by partner Tom Loverro), bringing the company's valuation to $1.25 billion and granting it unicorn status. New investors in the round included CapitalG (Alphabet's growth fund) and Sapphire Ventures, while existing backers Sequoia, Benchmark, and Amplify also participated. Strategic investors included ServiceNow Ventures, Workday Ventures, Cisco Investments, Datadog Ventures, Databricks Ventures, and Frontline.[8][9][10]
At the time of the Series B announcement, LangChain reported that 35% of Fortune 500 companies were using its services in some form, that the commercial LangSmith platform had grown 12x year-over-year in trace volume, and that the open-source packages were averaging 90 million monthly downloads. Reported customers included Cisco, Replit, Clay, Cloudflare, Workday, and ServiceNow. While LangChain declined to disclose exact ARR figures, the company indicated that earlier TechCrunch estimates of $12 million to $16 million were "low for where we are today."[3][10]
| Event | Date | Details |
|---|---|---|
| Initial release | October 2022 | Open-source Python library by Harrison Chase |
| LangChain, Inc. founded | Early 2023 | Co-founded by Harrison Chase and Ankush Gola |
| Seed round | April 2023 | ~$10 million from Benchmark |
| LangChain v0.1 | January 2024 | First versioned stable release after package split |
| Series A | February 2024 | $25 million led by Sequoia Capital ($200M valuation) |
| LangChain v0.3 | September 2024 | Pydantic 2 migration, modular package restructuring |
| LangChain and LangGraph 1.0 alpha | September 2025 | Major rewrite announced targeting late October GA |
| Series B | October 2025 | $125 million led by IVP ($1.25B valuation, unicorn status) |
| LangChain 1.0 GA | October 22, 2025 | First stable major release with create_agent API |
| LangGraph 1.0 GA | October 22, 2025 | Stable release for agent orchestration framework |
| LangChain 1.1 | December 2, 2025 | Model profiles, retry middleware, moderation middleware |
| Deep Agents 0.x | March 2026 | Planning, subagents, and persistent memory for long-horizon tasks |
| LangGraph 1.1 | March 2026 | Type-safe v2 streaming, per-node timeouts, graceful shutdown |
| Deep Agents v0.5 | April 7, 2026 | Async subagents and multi-modal filesystem support |
LangChain's architecture is organized around six primary categories of components: Models, Prompts, Chains, Agents, Memory, and Retrieval. These components are designed to be modular and composable, allowing developers to mix and match building blocks to construct sophisticated applications.[11]
At the center of any LangChain application is the model interface. LangChain provides a standardized abstraction layer for interacting with many different language model providers, including OpenAI, Anthropic, Google, Cohere, and Hugging Face. This abstraction allows developers to swap out underlying models without changing application logic.
LangChain supports three model types: LLMs (text-in, text-out), chat models (message-based interfaces), and text embedding models (used for vector search and similarity tasks). The framework includes prompt template utilities that help developers construct dynamic prompts with variable substitution, few-shot examples, and output formatting instructions.
Chains are sequences of operations assembled in a specific order to perform particular tasks. A chain might combine a prompt template, a model call, and an output parser into a single pipeline. For example, a summarization chain could load a PDF document, split its text into chunks, generate summaries for each chunk, and then combine those summaries into a final output.
LangChain includes implementations of many different chain types, covering use cases such as question answering over documents, SQL database querying, API interaction, and conversational retrieval. Developers can also compose custom chains by linking components together.[1]
In LangChain 1.0, legacy high-level chains such as LLMChain, ConversationChain, and SequentialChain were moved to the separate langchain-classic package to preserve backward compatibility while clearing the namespace for the modern Runnable and agent abstractions.[12]
While chains follow a predetermined sequence of steps, agents use a language model as a reasoning engine to decide which actions to take and in what order. An agent receives user input, determines which tools to call, processes the results, and iterates until it arrives at a final answer. This makes agents suitable for tasks where the required steps cannot be known in advance.[13]
LangChain provides several generic agent types, including ReAct agents (which alternate between reasoning and acting), plan-and-execute agents (which create a plan first, then execute each step), and OpenAI function-calling agents (which leverage the function-calling capabilities of specific models). Starting with LangChain 1.0, the create_agent abstraction provides the fastest way to build an agent with any model provider, built on the LangGraph runtime for reliability.[14][15] The older langgraph.prebuilt.create_react_agent helper and the legacy Agent and AgentExecutor classes have been deprecated in favor of create_agent.[12]
Tools are functions that an agent can invoke to interact with the outside world. LangChain ships with a collection of built-in tools and supports custom tool definitions. Common built-in tools include web search utilities, calculators, Python code interpreters, SQL database connectors, and API wrappers. Developers can define their own tools by wrapping any Python function with a tool decorator and providing a description that the agent uses to decide when and how to call it.[13]
Memory enables context retention across interactions. Without memory, each call to a language model is stateless. LangChain provides several memory implementations:
| Memory Type | Description |
|---|---|
| ConversationBufferMemory | Stores the full conversation history |
| ConversationSummaryMemory | Maintains a running summary of the conversation |
| ConversationBufferWindowMemory | Keeps only the last K interactions |
| ConversationTokenBufferMemory | Keeps interactions up to a token limit |
| VectorStoreRetrieverMemory | Stores memories in a vector store and retrieves the most relevant ones |
These memory modules can be attached to chains and agents, allowing applications to maintain coherent, multi-turn conversations.[16] In LangChain 1.0, in-loop summarization is provided as standard SummarizationMiddleware rather than as a separate memory object, with model-aware variants added in 1.1.[17]
LangChain's retrieval system supports retrieval-augmented generation (RAG), a technique that grounds language model responses in external data. The retrieval pipeline typically involves loading documents from a source, splitting them into chunks, generating embeddings, storing those embeddings in a vector database, and retrieving the most relevant chunks at query time.
The framework includes over 100 document loaders for ingesting data from PDFs, web pages, databases, APIs, and many other sources. It also provides more than 10 text splitting methods and integrations with dozens of vector stores, including Pinecone, Chroma, Weaviate, FAISS, Milvus, and Qdrant.[1]
LangChain's codebase underwent a significant architectural reorganization beginning in late 2023, moving from a monolithic package to a modular, multi-package structure. This split was completed with the release of LangChain v0.1 in January 2024 and refined further in v0.3.[18]
The original langchain package was divided into three core packages:
| Package | Purpose | Examples |
|---|---|---|
langchain-core | Core abstractions, interfaces, and LCEL runtime | Runnable, ChatModel, BaseTool, PromptTemplate |
langchain-community | Community-maintained third-party integrations | Vector stores, document loaders, embedding providers |
langchain | High-level agent and orchestration logic | create_agent, agents, messages, tools, chat_models |
langchain-classic | Legacy chains, retrievers, and indexing API | LLMChain, ConversationChain, MultiQueryRetriever |
In addition, first-party integrations from major providers are published as standalone packages for tighter version control. These include langchain-openai, langchain-anthropic, langchain-google-genai, langchain-mistralai, and others. This separation allows each integration to version independently and manage its own dependencies without affecting the broader ecosystem.[18]
Released in September 2024, LangChain v0.3 completed the migration from Pydantic 1 to Pydantic 2, removing the need for compatibility bridges like langchain_core.pydantic_v1. The release also dropped support for Python 3.8 and Pydantic 1 (both of which had reached end-of-life), made callbacks non-blocking by default, and simplified tool definition APIs. On the JavaScript side, all packages moved @langchain/core from a direct dependency to a peer dependency, giving developers explicit control over the core version used in their projects.[19]
Announced as an alpha in September 2025 and reaching general availability on October 22, 2025, LangChain 1.0 represented the first major stable release of the framework. The team substantially rewrote the library to be opinionated, focused, and powered by the LangGraph runtime. Key additions included:
create_agent API: A streamlined entry point for building agents with any model provider, replacing the older agent executor patterns.[14]HumanInTheLoopMiddleware), conversation summarization (SummarizationMiddleware), and PII redaction (PIIMiddleware), with support for custom middleware.[14]content_blocks property gives unified access to modern LLM features (reasoning traces, citations, server-side tool calls, and built-in tools) across Anthropic, AWS, OpenAI, Google GenAI, and Ollama integrations at launch.[12]langchain-classic: Legacy LLMChain-style chains, retrievers, the indexing API, the hub module, and langchain-community exports moved out of langchain into the langchain-classic companion package. Existing applications can migrate by switching from from langchain import ... to from langchain_classic import ....[12]Released on December 2, 2025, LangChain 1.1 introduced a model profile system in which chat models expose a .profile attribute describing their supported capabilities such as structured output, function calling, and JSON modes. These profiles are sourced from models.dev, an open-source project indexing model behaviors across providers, and the values flow automatically into ProviderStrategy selection and other middleware. The release also added retry middleware with configurable exponential backoff, an OpenAIModerationMiddleware for policy violation checking across user input, model output, and tool output, context-aware summarization that uses model profile metadata to decide when to compress history, and the ability to pass SystemMessage instances directly to create_agent for cache-control blocks and structured orchestration hints.[17]
LangChain Expression Language (LCEL) is a declarative syntax for composing chains of LangChain components. Introduced to simplify chain construction and provide built-in support for streaming, batching, and asynchronous execution, LCEL uses the Python pipe operator (|) to connect components in a left-to-right data flow.[20]
The core abstraction behind LCEL is the "Runnable" interface. Every LangChain component that implements the Runnable protocol can be invoked, batched, streamed, and composed with other Runnables. When two Runnables are combined with the pipe operator, the output of the first becomes the input of the second. Internally, the | operator works through Python's __or__ and __ror__ magic methods, which are defined on the Runnable base class. When two Runnables are piped together, LangChain constructs a RunnableSequence that manages the data flow.
A simple LCEL chain might look like:
chain = prompt | model | output_parser
LCEL also provides RunnableParallel for executing multiple operations concurrently and RunnableLambda for wrapping arbitrary Python functions into pipe-compatible components.
Key benefits of LCEL include:
LCEL itself remains the recommended composition layer in LangChain 1.x, sitting beneath create_agent and other high-level APIs. However, the older procedural chains it once accompanied, including LLMChain, ConversationChain, and SequentialChain, were deprecated starting in LangChain 0.1.17 and have been relocated to the langchain-classic package in LangChain 1.0. Applications still relying on those classes must add langchain-classic as an explicit dependency and update their imports.[12][21]
LangGraph is a framework for building stateful, multi-actor AI agent applications using graph-based orchestration. While LCEL and standard chains work well for linear workflows, LangGraph addresses the need for more complex agent architectures involving cycles, conditional branching, and persistent state.[22]
In LangGraph, an application is defined as a directed graph where nodes represent agents, functions, or decision points, and edges define how data flows between them. A centralized StateGraph maintains the workflow's shared state, typically defined as a TypedDict or Pydantic model that persists and accumulates information as it flows through the graph. This design allows for:
PostgresSaver, the system automatically saves a snapshot of the graph state at every step.LangGraph provides durable execution, meaning that if an agent workflow is interrupted (due to a crash, timeout, or human intervention), it can be resumed from its last checkpoint. The framework also includes built-in support for human-in-the-loop patterns, where execution can be paused at designated points for human review or approval before continuing.[22]
LangGraph supports multi-agent architectures where multiple specialized agents collaborate within a single graph. Each agent can have its own tools, prompts, and decision logic while sharing state through the centralized graph. This makes it possible to build systems where, for instance, a research agent gathers information, an analysis agent processes findings, and a writing agent produces output, all coordinated through the graph structure.
LangGraph 1.0 reached general availability on October 22, 2025, after powering agent systems at companies including Uber, LinkedIn, and Klarna. The 1.0 release marked a commitment to stability with no breaking changes until 2.0. Over 400 companies were running LangGraph in production at the time of release. The deprecation of the langgraph.prebuilt namespace, with its enhanced capabilities migrated to langchain.agents, was the primary breaking change at GA; everything else preserved backward compatibility.[23][24]
In March 2026, LangGraph 1.1 introduced an opt-in version="v2" streaming and invocation format for the stream(), astream(), invoke(), and ainvoke() methods. Each chunk emitted by v2 streams uses a unified StreamPart shape with type, ns, and data keys, and per-mode TypedDict definitions are exposed from langgraph.types. Synchronous invoke() calls in v2 return a GraphOutput object with .value and .interrupts attributes, and values-mode outputs are automatically coerced into declared Pydantic models or dataclasses. Other 1.1 additions include per-node timeouts with wall-clock and idle-reset variants, plus a graceful shutdown that stops in-flight runs cooperatively after the current superstep and saves a resumable checkpoint.[25]
The LangGraph Platform (rebranded as LangSmith Deployment in late 2025) provides managed infrastructure for deploying LangGraph applications. It handles scaling, state persistence, and monitoring for production agent systems, and integrates tightly with LangSmith for observability. Pricing follows a usage-based model measured in "nodes executed" and deployment minutes, with a free Developer tier supporting up to 100,000 nodes per month and managed Plus and Enterprise tiers for production workloads. A langgraph deploy CLI, released in early 2026, allows direct deployment to LangSmith from a developer's terminal without leaving the local environment.[22][26][27]
LangSmith is a developer platform for observability, testing, and evaluation of LLM applications. Unlike LangChain the framework, LangSmith is framework-agnostic; it can trace applications built with OpenAI SDK, Anthropic SDK, Vercel AI SDK, LlamaIndex, or custom implementations.[28]
LangSmith's tracing system breaks each run into a structured timeline of steps, showing exactly what happened, in what order, and why. Developers can inspect individual LLM calls, see the exact prompts sent, view token usage, and identify where errors or unexpected behavior occurred. The platform supports Python, TypeScript, Go, and Java SDKs, and added end-to-end OpenTelemetry support in March 2025 for integration with existing observability pipelines.[28]
LangSmith provides tools for systematic evaluation of LLM outputs. Developers can create datasets, define custom evaluators, and run automated test suites against their applications. The platform supports online evaluation (scoring production traffic in real time) and offline evaluation (running test suites against specific application versions). Pairwise annotation queues allow side-by-side comparison of outputs from different model versions or configurations. Evaluator types include human evaluation through annotation queues, heuristic checks, LLM-as-judge evaluators that score against defined criteria, and custom evaluators written in Python or TypeScript.[28]
LangSmith has introduced several AI-powered capabilities to assist with agent development:
LangSmith provides a unified view of costs across an entire agent workflow, tracking not just LLM call costs but also tool execution and retrieval costs. This visibility helps teams optimize spending as they scale their applications.
| Plan | Price | Included Traces |
|---|---|---|
| Developer | Free | 5,000/month |
| Plus | $39/user/month | 10,000/month |
| Enterprise | Custom | Custom |
LangSmith offers managed cloud, bring-your-own-cloud (BYOC), and self-hosted deployment options for teams with data residency requirements.[28]
The LangSmith Agent Builder, which entered public beta in 2025, provided a visual interface for creating and testing agents. It featured a central chat interface with all available tools, one-click conversion from conversations to agent configurations, file upload support, and a unified tool registry.[29] In March 2026, the product was renamed LangSmith Fleet and expanded with agent identity, sharing, and permissions features aimed at enterprise lifecycle management.[30] Around the same time, LangSmith Sandboxes entered private preview, providing locked-down temporary environments in which agents can execute code safely without access to production resources. Enterprise features added in this period include attribute-based access control (ABAC) layered on top of role-based access, plus tamper-resistant audit logs for administrative actions across organizations.[30]
LangChain supports the Model Context Protocol (MCP), an open standard originally developed by Anthropic for connecting AI agents to external tools and data sources. The official langchain-mcp-adapters package, maintained by the LangChain community with contributions from Anthropic, converts MCP tools into LangChain- and LangGraph-compatible tools, enabling interaction with tools across multiple MCP servers.[31]
The MultiServerMCPClient class manages connections to multiple MCP servers simultaneously. It is stateless by default: each tool invocation creates a fresh MCP ClientSession, executes the tool, and cleans up. The library supports multiple transport mechanisms for client-server communication, including HTTP and stdio transports.[31]
MCP has emerged as the de facto standard for tool integration in the AI agent ecosystem. In March 2025, OpenAI officially adopted MCP across its products. In December 2025, Anthropic donated MCP to the Agentic AI Foundation under the Linux Foundation, further solidifying its position as an industry standard. The langchain-mcp-tools library supports MCP Protocol version 2025-03-26 while maintaining backward compatibility with version 2024-11-05.[31]
Announced in March 2026, Deep Agents is an agent harness built on LangChain and LangGraph, designed for complex, long-horizon tasks that require planning, delegation, and persistent memory. The project represents LangChain's entry into the coding agent space alongside tools like Devin and GitHub Copilot.[32]
Core components of Deep Agents include:
write_todos): Enables agents to break down complex tasks into discrete steps, track progress, and adapt plans as new information emerges.read_file, write_file, edit_file, ls, glob, and grep, with pluggable backends (StateBackend, FilesystemBackend, LocalShellBackend, StoreBackend, and CompositeBackend).execute tool.The Deep Agents CLI can run interactively as a chat-style coding agent or non-interactively via piped input for scriptable, headless execution. Evaluated against Terminal Bench 2.0 (an 89-task benchmark spanning software engineering, biology, security, and gaming scenarios), the Deep Agents CLI scored approximately 42.65% using Claude Sonnet 4.5 as the underlying model.[32]
Deep Agents v0.4, shipped on February 17, 2026, added pluggable sandbox support, smarter conversation history summarization, and adoption of the Responses API as the default for OpenAI models.[33] Deep Agents v0.5, released on April 7, 2026, introduced asynchronous subagents that let a supervisor agent delegate long-running tasks to remote workers built on the Agent Protocol standard. Async subagents return a task ID immediately and run independently on a remote server, exposing five new tools (start_async_task, check_async_task, update_async_task, cancel_async_task, and list_async_tasks). The same release expanded the virtual filesystem beyond images, allowing Deep Agents to read PDFs, audio, video, and other file types through the unified read_file interface, with content type auto-detection from file extensions.[34]
LangServe is an open-source library that simplifies the deployment of LangChain applications as REST APIs. Built on top of FastAPI and Pydantic, LangServe automatically generates API endpoints for any LangChain Runnable, including /invoke, /batch, and /stream endpoints that support concurrent requests.[35]
Key features of LangServe include automatic input/output schema validation (inferred from the LangChain objects), interactive API documentation, a built-in web playground for testing deployed chains, and a client library for calling deployed endpoints from Python or JavaScript applications. LangServe supports deployment to platforms such as Google Cloud Run, AWS, and Replit. For LangGraph workloads, the LangSmith Deployment platform (formerly LangGraph Platform) is now the recommended host because it natively supports durable graph execution and checkpointing.[35][26]
One of LangChain's defining strengths is its extensive integration ecosystem. The framework connects to hundreds of external services and tools across several categories:
| Category | Examples | Approximate Count |
|---|---|---|
| LLM providers | OpenAI, Anthropic, Google, Cohere, Mistral, Meta Llama | 50+ |
| Vector stores | Pinecone, Chroma, Weaviate, FAISS, Milvus, Qdrant, pgvector | 40+ |
| Document loaders | PDF, HTML, CSV, Notion, Google Drive, S3, Confluence | 100+ |
| Tools | Web search, calculators, code interpreters, API wrappers, MCP servers | 50+ |
| Embedding models | OpenAI, Cohere, Hugging Face, Voyage AI, Google | 25+ |
| Callbacks/tracing | LangSmith, Weights & Biases, MLflow, Helicone, OpenTelemetry | 10+ |
Community-maintained integrations are published in the langchain-community package, while first-party integrations from major providers are distributed as standalone packages (e.g., langchain-openai, langchain-anthropic).[1]
In March 2026, LangChain announced a partnership with NVIDIA on an enterprise agentic AI platform and joined NVIDIA's Nemotron Coalition for open model advancement.[30]
The LangChain ecosystem encompasses several interconnected products and libraries. The following table summarizes the major components:
| Component | Type | Description | License |
|---|---|---|---|
langchain-core | Open-source library | Core abstractions, Runnable interface, LCEL runtime | MIT |
langchain | Open-source library | High-level agents, create_agent API, modern namespace | MIT |
langchain-classic | Open-source library | Legacy chains, retrievers, indexing API for backward compatibility | MIT |
langchain-community | Open-source library | Community-maintained integrations (vector stores, loaders, etc.) | MIT |
| LangGraph | Open-source framework | Graph-based agent orchestration with durable execution | MIT |
| LangSmith | Commercial platform | Observability, evaluation, tracing, Fleet, Sandboxes | Proprietary |
| LangServe | Open-source library | REST API deployment for LangChain Runnables | MIT |
| Deep Agents | Open-source framework | Planning, subagents, and memory for long-horizon tasks | MIT |
langchain-mcp-adapters | Open-source library | Bridge between LangChain/LangGraph and MCP servers | MIT |
| Partner packages | Open-source libraries | langchain-openai, langchain-anthropic, langchain-google-genai, etc. | MIT |
LangChain operates in an increasingly crowded market for LLM application frameworks. Several notable competitors have established distinct positions in the ecosystem.
LangChain and LlamaIndex are the two most widely used frameworks for building LLM applications, but they differ in scope and emphasis.
| Aspect | LangChain | LlamaIndex |
|---|---|---|
| Primary focus | General-purpose agent and chain orchestration | Data retrieval and search/RAG workflows |
| Architecture | Modular chains, agents, tools, memory | Query engines, indices, routers, fusers |
| Agent support | Extensive (ReAct, plan-and-execute, multi-agent via LangGraph) | Supported but not the primary focus |
| RAG capabilities | Full pipeline support via retrieval modules | Built-in, optimized query engines for RAG |
| Data ingestion | 100+ document loaders | Wide format support with structured extraction |
| Observability | LangSmith (dedicated platform) | LlamaTrace, third-party integrations |
| Best suited for | Complex agent workflows, multi-step reasoning, tool use | Document-heavy search, knowledge bases, Q&A over data |
| License | MIT | MIT |
LangChain excels in scenarios requiring dynamic agent behavior, tool use, and multi-step reasoning, while LlamaIndex is often preferred for applications centered on retrieval and question answering over large document collections. Many production systems use both frameworks together, with LlamaIndex handling data retrieval and LangChain managing the broader application logic.[36]
| Framework | Developer | Focus | Key Strength | Language Support |
|---|---|---|---|---|
| LangChain/LangGraph | LangChain, Inc. | Agent orchestration, chains, RAG | Largest ecosystem, durable graph execution | Python, TypeScript |
| LlamaIndex | LlamaIndex, Inc. | Data retrieval and RAG | Optimized query engines and data connectors | Python, TypeScript |
| Semantic Kernel | Microsoft | Enterprise LLM integration | Deep Microsoft ecosystem integration | C#, Python, Java |
| CrewAI | CrewAI, Inc. | Multi-agent role-based collaboration | Role-based agent teams with crew orchestration | Python |
| Haystack | deepset | Production RAG and NLP pipelines | Deterministic, high-quality production pipelines | Python |
| AutoGen | Microsoft | Multi-agent conversations | Conversational agent patterns (merged with Semantic Kernel) | Python, C# |
CrewAI, which raised $18 million in October 2024 in a round led by Insight Partners with participation from notable angels including Andrew Ng and Dharmesh Shah, focuses specifically on role-based multi-agent collaboration. It reports serving nearly half of the Fortune 500 and executing over 10 million agents per month.[37]
Haystack, developed by deepset, is a pipeline-centric framework that takes a directed acyclic graph (DAG) approach to building production NLP and RAG systems. Companies including Apple, Meta, NVIDIA, and Netflix use Haystack in production. Recent benchmarks suggest Haystack can match or outperform LangChain on certain RAG workloads, depending on the configuration.[38]
Microsoft merged its AutoGen and Semantic Kernel projects into a unified Agent Framework in 2025, positioning it as the enterprise-grade option with deep integration into Azure and the broader Microsoft ecosystem.[39]
LangChain has cultivated one of the largest open-source communities in the AI tooling space. Key community metrics, drawn from the company's October 2025 Series B announcement and follow-on data, include:
The project follows a modular package structure. The core abstractions live in langchain-core, while langchain-community houses community-maintained integrations and langchain-classic carries the deprecated chain APIs. First-party provider packages (such as langchain-openai and langchain-anthropic) are maintained separately for tighter version control. LangGraph, LangSmith, and Deep Agents have their own dedicated repositories and release cycles.[1]
Despite its popularity, LangChain has faced sustained criticism from portions of the developer community, particularly during 2023 and 2024. The backlash became prominent enough to be commonly referred to as "LangChain hate" on social media and developer forums.[40]
The most frequent criticism centers on LangChain's layered abstractions. Developers have described the framework as "over-engineered for simple tasks and fragile for complex ones," with abstractions piled on top of abstractions: chains, runnables, agents, tools, and callbacks all interacting in ways that can be difficult to reason about. For straightforward use cases (such as a single API call to an LLM), LangChain's overhead can feel disproportionate to the task.[40][41]
During 2023 and early 2024, LangChain's rapid development pace led to frequent breaking changes between versions. Developers reported that interfaces were a moving target, making it difficult to maintain production applications. The v0.3 and 1.0 releases explicitly addressed this concern by committing to backward compatibility and semantic versioning. Some teams upgrading to 1.0 in production reported that the move was smoother than expected once they had installed langchain-classic and updated imports for any deprecated chain code paths.[40][42]
The original monolithic langchain package pulled in dozens of dependencies for integrations that many users did not need. The package split into langchain-core, langchain-community, and standalone provider packages was a direct response to this criticism, allowing developers to install only the integrations they actually use.[41]
Some developers have reported that LangChain's abstractions, particularly memory components and agent executors, can add noticeable latency per API call. Debugging can also be challenging, with vague type hints and inconsistent execution tracing in earlier versions. LangSmith's tracing capabilities and the 1.0 rewrite aimed to address these debugging and performance concerns.[40]
Several companies, including Octomind, publicly documented their decision to remove LangChain from their tech stack in 2024, finding that direct API calls to LLM providers gave them more control and productivity. Others have argued that LangChain remains valuable for rapid prototyping and teams that benefit from its pre-built integrations, even if production systems sometimes outgrow its abstractions. The LangChain team has acknowledged much of this feedback, and the 1.0 rewrite with its streamlined API, middleware system, and focus on the LangGraph runtime was explicitly designed to address the most common complaints.[41][43]
As of mid-2026, LangChain has evolved significantly from its early days as a chain-composition library. The project now positions itself as a comprehensive "agent engineering platform" rather than simply an LLM framework.[9]
LangChain 1.0 represented a major rewrite of the framework, introducing create_agent as the primary entry point for agent development, a middleware system for agent loop control, improved structured output generation, standard content blocks across providers, and a commitment to API stability with breaking changes deferred until 2.0. Legacy chain APIs were preserved through the langchain-classic companion package. The 1.1 release in December 2025 added model profiles, retry middleware, OpenAI moderation middleware, and direct SystemMessage support for create_agent.[14][17]
LangGraph 1.0 became generally available in October 2025, with LangGraph 1.1 following in March 2026 to add type-safe v2 streaming, per-node timeouts, and graceful shutdown. The framework has established itself as the standard approach for building production agent systems within the LangChain ecosystem, with over 400 companies running it in production at the 1.0 GA milestone.[24][25]
LangSmith has continued to expand, with over 1 billion trace logs recorded and 12x year-over-year commercial trace growth at the time of the Series B announcement. Features added in 2025 and early 2026 include Polly (the AI debugging assistant), LangSmith Fetch (CLI trace access), the Insights Agent (scheduled automated analysis), automated trace clustering, cost monitoring across full agent workflows, the LangSmith Fleet visual interface (renamed from Agent Builder), Sandboxes for isolated agent code execution, attribute-based access control, and audit logs.[28][29][30]
The launch of Deep Agents in March 2026 signaled LangChain's expansion into the coding agent space, with built-in planning, subagent delegation, and persistent memory for complex, multi-step tasks. The April 2026 v0.5 release added async subagents and multi-modal filesystem support, while a partnership with NVIDIA on enterprise agentic AI was announced alongside LangChain joining NVIDIA's Nemotron Coalition.[32][34][30]
The broader trend in the LangChain ecosystem reflects the AI industry's shift from simple LLM wrappers toward robust, production-grade agent infrastructure. With its unicorn valuation, growing customer base, and expanding product surface, LangChain, Inc. is positioned as a central player in the agentic AI tooling landscape.
LangChain held its annual Interrupt conference on May 13 and 14, 2026 at The Midway in San Francisco. The agenda paired framework releases with enterprise deployment stories, and the keynote lineup included co-founder and CEO Harrison Chase, Andrew Ng of DeepLearning.AI, MongoDB CEO Chirantan "CJ" Desai, and Box co-founder and CEO Aaron Levie. Companies presenting production agent work included Lyft, LinkedIn, Toyota, LATAM Airlines, Honeywell, Coinbase, Chime, Rippling, monday.com, and Clay.[44]
Alongside the conference, on May 12, 2026 the team shipped a coordinated set of open-source releases: langchain 1.3.0, langgraph 1.2.0, and deepagents 0.6.0. The headline addition was a version 3 streaming protocol exposed through the stream(), astream(), and event-streaming methods. The v3 format is content-block centric, emitting typed per-channel projections such as run.values, run.messages, run.lifecycle, and run.subgraphs, with the run.messages projection yielding individual ChatModelStream objects per LLM call and typed sub-projections for text, reasoning, tool calls, and usage statistics. LangGraph 1.2 also introduced a DeltaChannel that cuts checkpoint overhead for long-running threads. Deep Agents 0.6 added an experimental CodeInterpreterMiddleware that allows agents to execute code and call tools programmatically inside a scoped QuickJS runtime.[45]
LangSmith was the focus of several launches unveiled at Interrupt. The LangSmith Engine entered public beta as an autonomous agent that watches production traces, clusters failures, opens pull requests with fixes, creates custom evaluators, and adds failing traces to offline evaluation suites. A new storage layer called SmithDB, built in Rust on Apache DataFusion and Vortex, was reported to make core LangSmith experiences up to 15 times faster, with median trace-tree loads at 92 milliseconds and median single-run loads at 71 milliseconds. LangSmith Sandboxes reached general availability, using hardware-virtualized microVMs with snapshots, blueprints, and a sandbox CLI for secure agent code execution. Other launches included Managed Deep Agents, an API-first hosted runtime served through a /v1/deepagents API with durable threads and checkpointing; a Context Hub for versioned, tagged management of agent context files; and a LangSmith LLM Gateway in private beta offering spend limits and PII and secrets redaction.[46]
In the weeks before Interrupt, the April 2026 product updates added more than 30 reusable LangSmith evaluator templates spanning safety, response quality, trajectory, and multimodal outputs, plus cost alerting that fires when LLM spend crosses configurable thresholds. LangSmith Fleet gained access to over 7,500 agent-optimized tools through an integration with Arcade.dev, along with role-based and attribute-based access controls for tools. Deep Agents added a single-command deepagents deploy that packages a model, instructions, tools, skills, and sandboxes into a horizontally scalable production server.[47]
LangChain also published its State of Agent Engineering report, based on a survey of more than 1,300 professionals conducted between November 18 and December 2, 2025. Among the findings, 57% of respondents reported agents running in production, up from 51% the prior year; 89% had implemented observability while 52% had adopted evaluations; roughly a third cited quality as the top barrier to production; and 57% were not fine-tuning models, relying instead on base models with prompt engineering and retrieval.[48] The company separately introduced LangChain Labs, an applied research initiative focused on continual learning for agents.[49]