Open Source Agent Stack | LangChain OSS Overview
The open source stack for building agents
Start with proven agent patterns when speed matters and drop down to lower-level primitives when you need more control.
Helping top teams ship great agents
.svg)
Three layers for building reliable agents
Deep Agents, LangChain, and LangGraph form one open source agent stack. Each layer builds on the one below it, so you can choose the right balance of abstraction and control for your use case.
Deep Agents
Production-ready harness with planning, memory, context management, subagents, and execution environments built in. It generalizes the patterns behind coding agents for use across domains.
LangChain
The core agent loop (create_agent), model and tool abstractions, integrations, and middleware (hooks).
LangGraph
The durable engine that powers agents in production. Its low level primitives support a balance of deterministic and agentic steps.
Trusted by the largest builder community in AI
200M+
Monthly Downloads
63%
Of Fortune 500 Using LangChain OSS
Pick your level of abstraction
Use Deep Agents for a production-ready harness, LangChain for framework primitives, and LangGraph for custom workflows with full control. You can move between them as your agent needs change.
Deep Agents
Build agents for complex, mission critical work
Deep Agents gives you a production-ready harness for building LLM-powered agents and applications. Deep Agents ships with built-in context management and abstractions for subagents, long term memory, and skills. Deep Agents are built to run reliably for long-running, large context tasks.
Use Deep Agents when you need to:
- Give agents memory, tools, skills, and filesystem access
- Delegate work to subagents with isolated context
- Manage long context without building summarization and offloading yourself
- Customize a powerful base harness without starting from scratch
LangChain
Build your harness with framework primitives
LangChain is the framework for building agents. It provides create_agent, a core agent loop built on LangGraph, plus the building blocks for models, inference providers, tools, messages, MCP, and middleware. Use LangChain when you want to assemble your own agent harness.
Use LangChain when you need to:
- Build around the standard agent loop with a model and tools
- Add middleware around the agent loop
- Inject guardrails, dynamic context, human review, or business logic
- Build a bespoke harness with your own defaults and controls
LangGraph
Custom agent workflows with full control
LangGraph is the runtime for custom agent workflows. It uses a graph-based model backed by a durable engine, with human-in-the-loop control, fault tolerance, streaming, persistence, and observability at every step. Use LangGraph when your agent doesn’t fit a standard loop, or when you need to combine deterministic and agentic steps in the same workflow.
Use LangGraph when you need to:
- Mix deterministic steps with agentic behavior
- Add custom approvals, interrupts, retries, and fault tolerance
- Model complex state transitions directly
- Build multi-agent systems with explicit coordination
- Control how every step of the agent runs
Learn with LangChain Academy
Build from first principles with free courses from LangChain Academy.
Course
Foundation: Introduction to Deep Agents \
Learn how to build long-running agents for complex workflows.](https://academy.langchain.com/courses/foundation-introduction-to-deepagents)
Course
Quickstart: LangGraph Essentials - Python \
Learn the essential components of LangGraph — including State, Nodes, Edges, and Memory.](https://academy.langchain.com/courses/langgraph-essentials-python)
Course
Foundation: Introduction to LangChain - Python \
Learn how to build agents with pre-built architectures and model integrations.](https://academy.langchain.com/courses/foundation-introduction-to-langchain-python)
Improve agents in production with LangSmith
LangSmith gives teams the systems to manage the full agent development lifecycle. Connect Deep Agents, LangChain, or LangGraph to LangSmith to trace agent behavior, test changes, monitor regressions, manage deployments, and apply governance controls.
Trace
Evaluate
Monitor
Deploy
Govern
Trace every model call, tool call, prompt, error, and run
Evaluate on real agent behavior
Monitor cost, latency, errors, and quality
Deploy agents on managed infrastructure
Govern token spend, rate routing, and sensitive data
S t a r t s h i p p i n g b e t t e r a g e n t s t o d a y
Get started with LangSmith, the platform for the full agent development lifecycle