Back to blog

The LangChain ecosystem in a nutshell: a map of tools for building AI agents

Paweł Twardziak14 min read
—
langchainlanggraphagents
The LangChain ecosystem in a nutshell: a map of tools for building AI agents

When someone says "I use LangChain", they usually mean one of several different things. The official documentation splits the open source stack into three kinds of tools (framework, runtime, harness) and puts a separate platform, LangSmith, on top of them [3][1]:

  • LangChain - an agent framework: abstractions and integrations for models, tools, and the agent loop [3].
  • LangGraph - a runtime and low-level framework for orchestrating long-running, stateful agents [3][5].
  • Deep Agents - a "harness", a ready-made, batteries-included kit with built-in tools for building complex agents [3][6].
  • LangSmith - a platform for tracing, evaluation, prompts, and deployment that works across frameworks [5][1].
  • or simply the whole platform treated as one thing.

The same word, several different things. The docs even dedicate a whole page, "Frameworks, runtimes, and harnesses", precisely to keep these apart [3].

Because LangChain is no longer a single library for stitching model calls together. Its makers position the whole thing outright as a platform for agent engineering, meant to improve every step of the agent development lifecycle [1]. This article is a map of that ecosystem: what is in it, what each piece is for, and where to start. No code.

Where it came from and what it is today

LangChain launched in the fall of 2022 as a single Python package, initially a personal side project by Harrison Chase [17]. A month later ChatGPT arrived and LangChain quickly became the default way to build applications powered by models [17].

Since then the center of gravity has shifted from simple applications to agents: systems built around the loop of model and tool calls that has become synonymous with the word "agent" today [17][3]. The ecosystem grew along with that shift. Today it consists of an open source part that you install yourself, plus the LangSmith platform for testing, deployment, and monitoring [2][1].

Two things are worth remembering up front. First, the open source stack is available in two languages, Python and JavaScript/TypeScript, with separate documentation for each [2]. Second, the name "LangChain" refers to both a specific framework and the whole platform. They are not the same thing.

How to think about the whole ecosystem: the agent lifecycle

The easiest way to arrange these tools is along the path that every agent will take anyway. The docs lay it out in stages: build, test, deploy, monitor, and govern [1].

The split is fairly clean:

  • The build stage is the open source stack: LangChain, LangGraph, and Deep Agents [2].
  • The test, deploy, monitor, and govern stages are covered by LangSmith [1].

Let us go through it in order.

Stage 1: Building (open source)

This is the heart of the ecosystem. The open source stack gives you three tools, and you choose between them depending on how much low-level control you need [2]. Importantly, all three sit on the same foundation: LangChain is built on LangGraph, and Deep Agents uses LangChain building blocks and the LangGraph runtime [3][4][5][6].

Deep Agents

The recommended starting point and the fastest way to get going [2]. Deep Agents is a harness: a batteries-included kit with built-in planning, subagents for delegating tasks, a file system, and context management (including summarizing a long conversation history) [3][6]. It is a standalone library (create_deep_agent) that uses LangChain building blocks and the LangGraph runtime, meant for complex, multi-step tasks that require planning and decomposition [3][6].

There is even a ready-made product built on this engine: Deep Agents Code (dcode), an open source terminal coding agent [2][24]. It works with any tool-calling model and lets you switch providers or models mid-session, has persistent memory across conversations, customizable skills, and approval controls before it executes code [24]. It proposes changes as diffs for your approval before touching files, and when needed it runs shell commands, checks the documentation, or searches the web [24].

LangChain

The framework proper. In version 1.0 its core is the create_agent function: a minimal, highly configurable agent harness and the standard way to build agents in LangChain [4][7]. Its makers describe it with the equation agent = model + harness: the harness is everything around the model loop, that is the prompt, the tools, and the middleware that shapes the agent's behavior [4].

LangChain provides abstractions such as standardized content blocks, the agent loop, and middleware, plus integrations with models and tools [3]. It is built on LangGraph, but you do not need to know LangGraph to use it [3].

Version 1.0 is, as its makers put it, a focused, production-ready foundation for building agents, organized around three changes: create_agent (replacing create_react_agent), standardized content blocks, and a slimmed-down langchain namespace (legacy functionality moved to langchain-classic) [7].

LangGraph

The lowest level. LangGraph is a low-level orchestration framework and runtime for building, managing, and deploying long-running, stateful agents [5]. It is used by Klarna, Uber, and J.P. Morgan, among others [5].

At this level you get the concrete capabilities orchestration needs: durable execution (an agent survives a failure and resumes from where it left off), streaming, human-in-the-loop (a person can inspect and modify the agent's state), and persistent memory at the thread level and across threads [3][5]. You reach for LangGraph when you need fine-grained control or when you are building complex workflows that combine deterministic and agentic steps [3].

In short: Deep Agents for a fast start, LangChain for standard abstractions while keeping flexibility, LangGraph for low-level control over long-running agents [3].

Integrations

Integrations deserve a separate mention, because they are one of the main reasons people reach for LangChain in the first place. The Python version offers over 1000 integrations: chat and embedding models, tools, document loaders, vector stores, and more [8]. Instead of writing your own connector to every provider, you take a ready-made one.

MCP: a shared language for tools

The Model Context Protocol (MCP) is an open protocol that standardizes how applications expose tools and context to models [21]. In the LangChain ecosystem it works both ways, and it is one of the more interesting threads.

On one side, a LangChain agent can use tools exposed by external MCP servers through the langchain-mcp-adapters library. A single client (MultiServerMCPClient) connects to many servers at once, local ones over the stdio transport and remote ones over HTTP, and their tools reach the agent alongside the built-in ones [21].

On the other side, your deployed agent can itself be exposed as an MCP tool. Agent Server implements MCP over the Streamable HTTP transport and exposes a /mcp endpoint, so any MCP-compliant client can use your LangGraph agent [22]. On top of that, LangSmith itself exposes a remote, authenticated MCP server through which a model can reach platform data, including prompts, runs, and datasets [23].

In other words: in this ecosystem MCP is both an input (the agent takes someone else's tools) and an output (your agent becomes someone else's tool).

Stage 2: Testing and evaluation

This is where LangSmith comes in. The problem it solves at this stage is familiar to anyone who has built something on models: how do you know your agent works well, when a model's answer is not deterministic.

For this LangSmith gives you evaluations over datasets and prompt engineering [1][10]. You collect a set of examples, define the expected result, and score the agent's answers. The score can be given by another model (the "LLM as a judge" approach), a rule in code, or a human [10].

Stage 3: Deployment

Getting an agent into production is handled by LangSmith Deployment. A note for those who have followed the topic longer: this product used to be called "LangGraph Platform" and has been renamed. Quoting the official changelog: "LangGraph Platform is now LangSmith Deployment and LangGraph Studio is now LangSmith Studio" [14].

LangSmith Deployment is an orchestration runtime purpose-built for agent workloads. It provides durable execution, real-time streaming, and horizontal scaling [11]. It is framework-agnostic, so you can also deploy agents built outside LangChain through it, for example on Google ADK, Claude Agent SDK, Strands, CrewAI, or AutoGen [11]. The engine is called Agent Server and can run in several hosting models: a fully managed cloud (run by LangChain on AWS and GCP), a standalone server in a container, or a full self-hosted platform in your own infrastructure [11]. Deploying from GitHub to production is one click [14].

LangSmith Studio

At deployment time it is worth knowing one more tool: Studio (today under the name LangSmith Studio) [14]. It is a specialized agent IDE: you visualize the agent's graph, run it and interact with it, manage threads and assistants, iterate on prompts, and debug state by stepping back in time (time travel) [12]. Studio v2 runs locally without the desktop app and lets you download production traces to debug them on your own machine [14].

Stage 4: Monitoring and governance

The last leg of the cycle is the agent's life in production. LangSmith spans three core services: observability, evaluation, and deployment [14].

Observability in LangSmith is tracing: you instrument the application, review individual traces, and monitor performance in production [9]. When an agent behaves unexpectedly, you open the specific trace and see what happened. Importantly, LangSmith works with many frameworks and providers, not only LangChain, including OpenAI, Anthropic, CrewAI, Vercel AI SDK, and Pydantic AI [9].

On top of this sit additional platform pieces:

  • Engine is an agent for agent engineering: from production traces it detects recurring issues, diagnoses their root cause, proposes a fix, generates an evaluator to guard against regressions, and creates dataset examples. It can open the fix as a pull request for agents built on Deep Agents, LangChain, or LangGraph [13].
  • Govern is the administrative layer: managing access and settings, plus the LLM Gateway [1].
  • Fleet is building and running agents without code, based on templates, integrations, and routine automation [5][15].
  • Sandboxes are managed, isolated environments for safely running agent-generated code and working with files [18].

What you can actually build with this

A short map of use cases, each based on the components from the stages above:

  • RAG, that is answering questions from your own documents, based on integrations with vector stores and retrievers [8].
  • A single agent with access to tools: create_agent from LangChain or Deep Agents [4][6].
  • Multi-agent systems: subagents in Deep Agents or orchestration in LangGraph [3].
  • Workflows that combine deterministic and agentic steps. This is LangGraph's domain [3].
  • Coding agents, like the aforementioned dcode [2].

Where to learn this

Around the core there is an educational layer. LangChain Academy offers free courses on building with LangChain and LangGraph, there is a community forum, and separate documentation for Python and TypeScript [1][16][2].

When LangChain, and when not

It is worth knowing that LangChain is not the only option, and here we can stay within the bounds of the official materials, because the documentation is honest about it.

First, you do not need to use LangChain to use LangGraph [3][5]. Second, the "Frameworks, runtimes, and harnesses" page explicitly lists alternatives at every level of the stack: for frameworks, Vercel AI SDK, CrewAI, OpenAI Agents SDK, Google ADK, and LlamaIndex; for runtimes, Temporal and Inngest; for harnesses, Claude Agent SDK and Manus [3].

The docs also give concrete selection criteria [3]:

  • LangChain, when you want to build agents quickly, need standard abstractions for models, tools, and the agent loop, and want an easy start without complex orchestration.
  • LangGraph, when you need fine-grained, low-level control, durable execution for long-running, stateful agents, or production-ready infrastructure for deployment.
  • Deep Agents, when you are building agents that run for a long time, face complex, multi-step tasks, and want ready-made tools (file operations, shell execution, automatic context management) along with predefined prompts and subagents.

In other words: the closer you get to a production, multi-part system, the more this ecosystem gives you. For a simpler task, it is worth first asking whether you need a full framework at all.

Where to start

Depending on where you are:

  • Want something working as fast as possible? Start with Deep Agents, the officially recommended starting point [2].
  • Prefer to assemble an agent from building blocks? LangChain and create_agent [4].
  • Already have an agent and want to understand it? Connect LangSmith for tracing and see what the agent actually does step by step [9].
  • Going to production? That is when evaluations, LangSmith Deployment, and monitoring come into play [1].

You do not need to learn the whole ecosystem at once. Learn the build stage, build something small, and pick up the rest when you actually need it.

Summary

LangChain is not a single library, but an open source stack for building (LangChain, LangGraph, Deep Agents) plus the LangSmith platform for testing, deployment, and monitoring, arranged along the agent lifecycle [1][2][3]. Learn the map, pick your starting point, and add the next pieces as you need them.

Building agents that actually work in production is exactly what we teach in practice at Soft 3.0. If you want to move from "stitching something together on LangChain" to deliberately designing agentic systems, see the course.

FAQ

How does LangChain differ from LangGraph? LangChain is an agent framework with ready-made abstractions (create_agent, model, tools, middleware). LangGraph is a low-level runtime for orchestrating long-running, stateful agents. LangChain is built on LangGraph, but you do not need to know LangGraph to use it. You reach for LangGraph when you need low-level control, durable execution, and mixing deterministic with agentic steps [3][5].

Is LangChain free? The open source stack (LangChain, LangGraph, Deep Agents) is open source and you run it yourself [2]. LangSmith is a platform with a free starting tier and paid plans above it [1][20].

Python or JavaScript? Both are first-class, with separate documentation [2]. The Python version has over 1000 integrations, while JS/TS has its own, wide list of integrations [8][19].

What are Deep Agents? A harness, that is a batteries-included kit with built-in planning, subagents, a file system, and context management, built on LangGraph. It is the officially recommended starting point when you want to quickly stand up an agent for a complex, multi-step task [2][3][6].

Do I have to use LangSmith to use LangChain? No. The open source stack works on its own. You add LangSmith when you need observability, evaluation, or deployment. LangSmith also works with agents outside LangChain [9].

What was "LangGraph Platform"? It is the earlier name of the agent deployment product. Today it is called LangSmith Deployment, and the Studio counterpart is LangSmith Studio. The change comes straight from the official changelog [14].

Sources

All substantive content has been verified against the official LangChain documentation (docs.langchain.com) and the official blog. As of July 2026.

  1. Docs by LangChain, platform home page ("The platform for agent engineering", Build/Test/Deploy/Monitor/Govern cards, Fleet, Academy) - https://docs.langchain.com/
  2. Build overview (open source stack, choosing by level of control, two languages, Deep Agents Code dcode) - https://docs.langchain.com/build-overview
  3. Frameworks, runtimes, and harnesses (framework/runtime/harness definitions, "when to use" table, list of alternatives) - https://docs.langchain.com/oss/python/concepts/products
  4. LangChain overview (create_agent, "agent = model + harness", middleware) - https://docs.langchain.com/oss/python/langchain/overview
  5. LangGraph overview (runtime, Klarna/Uber/J.P. Morgan, "you don't need LangChain to use LangGraph", Engine, Fleet) - https://docs.langchain.com/oss/python/langgraph/overview
  6. Deep Agents overview - https://docs.langchain.com/oss/python/deepagents/overview
  7. LangChain v1 (production-ready foundation, three changes, langchain-classic) - https://docs.langchain.com/oss/python/releases/langchain-v1
  8. Integrations - providers overview (Python, 1000+ integrations) - https://docs.langchain.com/oss/python/integrations/providers/overview
  9. LangSmith Observability (tracing, list of supported frameworks) - https://docs.langchain.com/langsmith/observability
  10. LangSmith Evaluation (datasets, LLM-as-judge, evaluators) - https://docs.langchain.com/langsmith/evaluation
  11. LangSmith Deployment (Agent Server, framework-agnostic, hosting models, AWS/GCP) - https://docs.langchain.com/langsmith/deployment
  12. LangSmith Studio (agent IDE, time travel, prompt iteration) - https://docs.langchain.com/langsmith/studio
  13. LangSmith Engine (detecting issues and proposing fixes) - https://docs.langchain.com/langsmith/engine-overview
  14. LangSmith changelog (rename "LangGraph Platform -> LangSmith Deployment", "LangGraph Studio -> LangSmith Studio", three services, one-click deploy, Studio v2) - https://docs.langchain.com/langsmith/changelog
  15. LangSmith Fleet (no-code agents) - https://docs.langchain.com/langsmith/fleet
  16. LangChain Academy (free courses) - https://academy.langchain.com/
  17. LangChain blog, "Reflections on Three Years of Building LangChain" (launch in fall 2022, single Python package, ChatGPT a month later, the tool-calling loop as a synonym for agent) - https://www.langchain.com/blog/three-years-langchain
  18. LangSmith Sandboxes (isolated environments for safely running code and working with files) - https://docs.langchain.com/langsmith/sandboxes
  19. Integrations - providers overview (JavaScript/TypeScript, "wide variety of integrations") - https://docs.langchain.com/oss/javascript/integrations/providers/overview
  20. LangSmith Plans and Pricing (free starting tier, paid plans) - https://www.langchain.com/pricing
  21. LangChain, Model Context Protocol (MCP) (langchain-mcp-adapters, MultiServerMCPClient, stdio/HTTP transports) - https://docs.langchain.com/oss/python/langchain/mcp
  22. LangSmith, Agent Server as an MCP server (/mcp endpoint, Streamable HTTP transport, LangGraph agent exposed as an MCP tool) - https://docs.langchain.com/langsmith/server-mcp
  23. LangSmith Remote MCP (remote, authenticated MCP server over platform data: prompts, runs, datasets) - https://docs.langchain.com/langsmith/langsmith-remote-mcp
  24. Deep Agents Code overview (dcode, terminal coding agent, any tool-calling model, mid-session model switching, memory, skills, approval, diffs) - https://docs.langchain.com/oss/python/deepagents/code/overview