Skip to main content
ToolAutomationfreemiumactive8-8.9
8.8/10Strong
Active

$0 library / $39 Plus / LCU/LSU usage meters

Best plan

$0 library / $39 Plus / LCU/LSU usage meters

Risk: LangGraph is a low-level developer framework, not a...

Try LangGraph free

Editorial · no paid placements

Should you use it?

LangGraph is LangChain's low-level runtime for long-running, stateful agents and workflows. The library is MIT-licensed and free for Python and JavaScript/TypeScript teams; LangSmith adds paid observability and deployment, with Developer at $0/seat/month, Plus at $39/seat/month, Enterprise custom, and LCU/LSU usage meters as of July 30, 2026. Pick it when you need durable execution, persistence, streaming, or human approval. Skip it for simple one-shot calls or no-code automation.

  • Buy ifPython and JavaScript teams building production agents
  • Pick$0 library / $39 Plus / LCU/LSU usage meters
  • Skip ifSimple single-turn LLM calls

Plan guidance

What to buy

Best plan$0 library / $39 Plus / LCU/LSU usage meters

Watch: LangGraph is a low-level developer framework, not a...

Price range$0 library / $39 Plus / LCU/LSU usage meters

$0 Developer / $39 Plus / Enterprise custom / $1.50 LCU / $1.00 LSU

Upgrade only ifNot for simple single-turn llm calls

LangGraph is a low-level developer framework, not a...

Current pricing source: LangChain pricing

Fit

Use it for this, skip it for that

Best for

  • Python and JavaScript teams building production agents
  • Long-running stateful agent workflows
  • Teams already using LangChain or LangSmith
  • Graph-native agent architectures with loops, conditional branches, and human approval

Avoid if

  • Simple single-turn LLM calls
  • No-code teams that want a visual builder
  • Teams trying to avoid the LangChain ecosystem entirely
Watch out
LangGraph is a low-level developer framework, not a finished business app; teams own graph design, state, persistence, evaluation, deployment, debugging, and LangSmith usage controls.

Recent changes

Only what affects the decision

  1. LangSmith Developer / Plus / Enterprise / usage meters

    Current public pricing uses Developer and Plus seats plus LCU/LSU meters for Deployment, Fleet, Engine, and...

    LangChain pricing
  2. LangSmith Developer / Plus / Enterprise

    Reverified public plan ladder: Developer has 5k included base traces, Plus has 10k included base traces and access to Deployment/Sandboxes/Engine, and Enterprise is custom

    LangChain pricing
  3. LangSmith Developer / Plus / Deployment

    Re-verified Developer 5k base traces, Plus 10k base traces, one included dev-sized deployment, 500 Fleet runs, deployment-run billing, dev/production uptime rates, Fleet overage, Engine...

    LangChain pricing

Alternatives

Best swaps

Microsoft Agent Framework

Microsoft's open-source agentic AI engine, merging Semantic Kernel and AutoGen, now sitting beside the Work IQ, Foundry, Copilot

Free (open source) · 9/10Langfuse

Open-source LLM engineering platform for observability, prompt management, evals, datasets, and OpenTelemetry tracing. ClickHous

$0 free / $29 Core / $199 Pro / $2,499 Enterprise · 8.8/10LinkedIn Recruiter

LinkedIn's recruiting platform with Hiring Assistant, AI-assisted sourcing, candidate messaging, applicant review, projects, rep

Contact sales; Hiring Assistant is an add-on · 8.8/10
Build comparison
Proof and score mathVerified Jul 30

Proof

Why this recommendation is trusted

EvidenceLangGraph documentation
Source
Registered source
Freshness
Current
Confidence
High confidence
Verified
Review
Volatility
Volatile

High-volatility evidence needs frequent review.

Editorial score

Unweighted average of 4 axes · confidence high

  • Utility9/10

    How much real work it can do for a competent operator, end to end.

  • Value9/10

    What you get for the dollar relative to the closest alternative.

  • Moat8/10

    How hard it would be for a competitor to replicate the underlying advantage.

  • Longevity9/10

    How likely the product is to still be best-in-class 24 months out.

Verified facts

  1. Best ForBest for engineering teams building long-running, stateful agents and workflows that need durable execution, streaming, human-in-the-loop controls, persistence, or multi-agent coordination.
    highDrifts2026-07-30LangGraph documentation
  2. Pricing AnchorLangGraph is free and MIT-licensed; current paid LangSmith layers include Developer at $0/seat/month with 5k included base traces, Plus at $39/seat/month with 10k included base traces and access to Deployment, Engine, and more, Enterprise custom, plus LCU/LSU pay-as-you-go meters for deployment, Fleet, Engine, sandboxes, traces, and storage.
    highVolatile2026-07-30LangChain pricing
  3. Watch Out ForLangGraph is a low-level developer framework, not a finished business app; teams own graph design, state, persistence, evaluation, deployment, debugging, and LangSmith usage controls.
    highDrifts2026-07-30LangGraph documentation
  4. Runtime ArchitectureLangGraph is positioned as the orchestration runtime for durable execution, streaming, human-in-the-loop, and persistence, while LangSmith provides tracing, evaluation, prompts, and deployment across frameworks.
    highDrifts2026-07-30LangGraph documentation
  5. Deployment BillingLangSmith Deployment is the current hosted-agent layer. Cloud Deployment requires Plus or above, while Enterprise unlocks self-hosted control-plane options. Public pricing now meters Deployment, Fleet, Engine, and Sandboxes through LCUs and LSUs, with one free small serverless deployment included on Plus.
    highVolatile2026-07-30LangSmith billing documentation
  6. Open SourceThe GitHub repository identifies LangGraph as an MIT-licensed low-level orchestration framework for stateful agents and points JavaScript/TypeScript users to LangGraph.js and the JS docs.
    highDrifts2026-07-30LangGraph GitHub repository
Full review notesLong-form details, FAQ, and source history

LangGraph is LangChain’s low-level orchestration runtime for stateful AI agents. Where LangChain gives you higher-level agent APIs, LangGraph gives developers explicit control over graphs, state, persistence, interrupts, streaming, and multi-agent workflows.

System Verdict

Pick LangGraph if you are building production agents that need more than one LLM call. It is strongest when the workflow must branch, loop, pause for approval, persist state, recover after failure, or coordinate multiple agents.

Skip it if the job is a simple prompt, tool call, or no-code workflow. Direct provider SDKs, LangChain’s higher-level agent API, Mastra, CrewAI, or LangFlow can be faster depending on the team and abstraction level.

Commercial reality: the LangGraph library is free and MIT-licensed. The paid layer is LangSmith: Developer is $0/seat/month with 5k base traces, Plus is $39/seat/month with 10k base traces and one free small serverless deployment, Enterprise is custom, and Deployment, Fleet, Engine, Sandboxes, traces, and storage use LCU/LSU or trace-based meters.

Key Facts
Last verifiedJuly 30, 2026
LicenseMIT for the library
LanguagesPython and JavaScript/TypeScript
Current product shapeLangGraph for orchestration; LangSmith for tracing, evaluation, prompts, and deployment
Official proof pointsLangChain’s docs/site list companies including Klarna, Uber, J.P. Morgan, Replit, Elastic, and more
Core conceptsDurable execution, persistence, streaming, interrupts, memory, subgraphs
Library cost$0
LangSmith plansDeveloper $0/seat/month (5k base traces); Plus $39/seat/month (10k base traces, one free small serverless deployment, access to Deployment/Engine); Enterprise custom
LangSmith tracesOfficial usage docs say base traces cost .05 cents per trace and extended retention costs .50 cents total per trace; base retention is 14 days, and docs state 400-day default extended retention while the pricing FAQ still says 180 days.
LangSmith DeploymentPlus includes one free small serverless deployment; additional Deployment, Fleet, Engine, and Sandbox usage is metered in LCUs/LSUs instead of the older per-run and uptime table.
Hosted deployment namingLangSmith Deployment, formerly LangGraph Platform
RelatedDeep Agents: LangChain’s higher-level harness built on LangGraph

When to pick LangGraph

  • Long-running stateful agents. Research pipelines, support workflows, code agents, and process automations that need to remember state and resume cleanly fit LangGraph’s design.
  • Durable execution matters. LangGraph is built for workflows that can recover from failures and keep running over time, not just one request-response loop.
  • Human-in-the-loop workflows. Interrupts let a team inspect, edit, approve, or reject state before the agent continues.
  • Multi-agent or subgraph systems. Subgraphs help split complex agent behavior into smaller units without giving up central state control.
  • LangSmith is already part of the stack. The first-party tracing, evals, Studio, and Deployment path are smoother when the team is comfortable with LangChain’s ecosystem.

When to pick something else

  • Simple one-shot LLM calls: direct OpenAI, Anthropic, or Google SDKs.
  • TypeScript-first agents with product-style ergonomics: Mastra is purpose-built for TypeScript teams.
  • Visual no-code or low-code building: LangFlow gives a canvas for LangChain and LangGraph workflows.
  • Role-based multi-agent prototypes: CrewAI is easier when the mental model is “crew of specialist agents” rather than explicit graph state.
  • Azure-aligned enterprise: Microsoft Agent Framework is the more natural fit when Azure AI Foundry is the default platform.

What changed recently
  • July 30 source recheck: LangGraph’s current docs still position it as the low-level orchestration runtime for durable execution, streaming, human-in-the-loop control, memory, and persistence, with LangSmith as the tracing/evaluation/prompt/deployment platform.
  • LangSmith deployment pricing changed. The public pricing page now shows Deployment, Fleet, Engine, and Sandboxes metered in LCUs/LSUs, with one free small serverless deployment on Plus. The older per-run and uptime numbers should no longer be used as current pricing.
  • Trace pricing is now framed as base charges plus extended-retention upgrades. Usage docs state .05 cents per base trace and .50 cents total for extended-retention traces. They also state 400-day default extended retention, while the pricing FAQ still contains a conflicting 180-day sentence.
  • Deployment scope widened in the docs. LangSmith Deployment is now framed as framework-agnostic agent infrastructure: LangGraph/LangChain are first-party paths, while Deep Agents, Google ADK, and other frameworks can also route through the same Agent Server runtime.
  • Fleet and infrastructure meters matter. Fleet, Engine, Deployment, and Sandboxes now use LCU and LSU meters, so production costs depend on compute, memory, storage, and agent workload behavior.

Pricing

ProductCurrent public priceNotes
LangGraph library$0MIT-licensed open-source framework
LangSmith Developer$0/seat/monthOne seat plus 5k included base traces per month
LangSmith Plus$39/seat/month10k included base traces, one free small serverless deployment, access to Deployment, Engine, and more
LangSmith traces (base).05 cents per trace14-day retention, equivalent to $0.50 per 1k traces after included allowance
LangSmith traces (extended).50 cents total per traceUsage docs say extended retention is 400 days by default; pricing FAQ still says 180 days, so treat the docs as the safer operational source and verify before committing high-retention spend
LangSmith DeploymentLCU/LSU meteredPlus includes one free Serverless Small deployment; additional Serverless and Dedicated deployments are charged by resource consumption
Fleet, Engine, and SandboxesLCU/LSU meteredFleet and Engine consume LCUs; Sandboxes consume LCU compute/memory and LSU storage
LCU / LSU units$1.50 per LCU / $1.00 per LSUPublic calculator defines LCUs for compute/work and LSUs for traces/storage
LangSmith EnterpriseCustomAdds alternative hosting, custom SSO/RBAC, and dedicated support

Pricing verified July 30, 2026 against LangChain’s public pricing, LangSmith billing docs, and LangSmith usage-and-billing docs. Model/API provider costs are separate from LangSmith.

Failure Modes
  • Low-level by design. LangGraph does not hide the agent architecture. Teams must still design state, tools, routing, evals, and deployment behavior.
  • Billing has multiple meters. Seats, base traces, extended-retention upgrades, Deployment LCUs/LSUs, Fleet LCUs, Engine LCUs, Sandbox compute/storage, and third-party model costs can all matter once LangSmith is in production.
  • Resource meters replaced the old uptime shorthand. Do not estimate current Deployment spend from the old per-run or per-minute numbers. Use LangChain’s public calculator and resource rates, then tear down unused deployments and sandboxes.
  • Model spend is separate. LangSmith can price seats, traces, deployments, Fleet, Engine, and sandbox compute, but OpenAI, Anthropic, Google, Mistral, or local-infrastructure model costs still sit outside the LangSmith bill.
  • Verbose for simple work. call or straightforward tool call is usually cleaner with a direct SDK.
  • LangChain conventions still show up. LangGraph can be used standalone, but many real projects use LangChain message, tool, and model abstractions around it.
  • Python examples are the deepest path. JavaScript/TypeScript support is real, but Python remains the more mature documentation and community path.

Against the Alternatives

LangGraphMastraMicrosoft Agent FrameworkCrewAIAG2
Primary fitStateful production agentsTypeScript agents and workflowsAzure enterprise agentsRole-based crewsAutoGen-style multi-agent work
Main languagePython + JavaScript/TypeScriptTypeScript.NET + PythonPythonPython
License postureMIT libraryOpen sourceOpen sourceOpen sourceOpen source
Control modelExplicit graph state and edgesAgent/workflow primitivesAgents plus workflowsAgents with roles/goalsConversational agent patterns
Hosted pathLangSmith DeploymentMastra Cloud/platform pathAzure AI FoundryCrewAI EnterpriseSelf-host/community first
Best forDurable stateful agentsTS-first product teamsMicrosoft/Azure buyersFast crew prototypesAutoGen continuation

Methodology

Produced by the aipedia.wiki editorial pipeline. Last verified July 30, 2026 against LangGraph official materials, LangGraph Python and JavaScript docs, LangChain pricing, LangSmith billing docs, LangSmith usage-and-billing docs, LangSmith Deployment docs, the LangGraph GitHub repository, and the LangChain/LangGraph v1.0 announcement.

FAQ

Is LangGraph really free? Yes. The LangGraph library is MIT-licensed and free to use. Paid spend starts when a team uses LangSmith services such as observability, evaluation, or hosted deployment.

What replaced LangGraph Platform? LangChain’s current public product language calls the hosted layer LangSmith Deployment. LangSmith billing docs describe it as the deployment product formerly called LangGraph Platform.

Do I need LangChain to use LangGraph? No. LangGraph can be used standalone, but the docs commonly use LangChain components for models and tools, and many teams pair it with LangSmith for tracing and evals.

What’s the difference between LangGraph and LangChain? LangChain is the higher-level agent framework. LangGraph is the orchestration runtime underneath or beside it when you need durable execution, persistence, human-in-the-loop, streaming, and explicit state control.

Does LangGraph compete with Mastra? Yes, especially for TypeScript teams choosing an agent/workflow framework. LangGraph has the broader LangChain/LangSmith ecosystem; Mastra often feels more native for TypeScript-first product engineering.

Sources

Review History

  • 2026-06-12: Re-verified LangGraph/LangSmith pricing and deployment docs, removed unsupported Claude model/vendor release claims, added current LangSmith Engine, sandbox, Fleet, deployment, and framework-agnostic deployment context.
  • 2026-06-24: Re-verified LangSmith Developer, Plus, Enterprise, deployment, traces, and billing docs; kept the buyer warning focused on multiple usage meters rather than a flat framework price.
  • 2026-07-30: Rechecked official LangGraph, LangSmith pricing, usage/billing, billing, deployment, official site, and repository sources. Replaced stale per-run uptime pricing with current LCU/LSU meters and noted the 400-day versus 180-day extended-retention source conflict.
  • 2026-06-24: Rechecked LangGraph Python and JavaScript overview docs plus LangChain pricing and LangSmith billing. No pricing change found at that time; kept the Developer, Plus, Enterprise, deployment, traces, Fleet, Engine, and sandbox warning.
  • 2026-05-13: Itemized LangSmith Deployment uptime ($0.0007/min dev, $0.0036/min production), base vs extended trace pricing, Fleet runs, and added a price_history block.
  • 2026-05-10: Refreshed LangGraph pricing, hosted deployment naming, source-backed buyer guidance, and current verification language.
  • 2026-04-18: Initial agent-framework review.
ShareLinkedIn
Was this review helpful?
Embed this score on your siteFree. Links back.
LangGraph editorial score badge
<a href="https://aipedia.wiki/tools/langgraph/" target="_blank" rel="noopener"><img src="https://aipedia.wiki/badges/langgraph.svg" alt="LangGraph on aipedia.wiki" width="260" height="72" /></a>
[![LangGraph on aipedia.wiki](https://aipedia.wiki/badges/langgraph.svg)](https://aipedia.wiki/tools/langgraph/)

Badge value auto-updates if the editorial score changes. Attribution via the link is required.

Cite this pageFor journalists, researchers, and bloggers
According to aipedia.wiki Editorial at aipedia.wiki (https://aipedia.wiki/tools/langgraph/)
aipedia.wiki Editorial. (2026). LangGraph: Editorial Review. aipedia.wiki. Retrieved August 3, 2026, from https://aipedia.wiki/tools/langgraph/
aipedia.wiki Editorial. "LangGraph: Editorial Review." aipedia.wiki, 2026, https://aipedia.wiki/tools/langgraph/. Accessed August 3, 2026.
aipedia.wiki Editorial. 2026. "LangGraph: Editorial Review." aipedia.wiki. https://aipedia.wiki/tools/langgraph/.
@misc{langgraph-editorial-review-2026, author = {{aipedia.wiki Editorial}}, title = {LangGraph: Editorial Review}, year = {2026}, publisher = {aipedia.wiki}, url = {https://aipedia.wiki/tools/langgraph/}, note = {Accessed: 2026-08-02} }
Spotted an error or want to share your experience with LangGraph?

Every tool page is re-verified on a recurring cycle, and corrections land faster when readers flag them directly. If you spot a stale fact, a missing capability, or have used LangGraph and want to share what worked or didn't, the editorial desk reviews every message sent through this form.

Email editorial@aipedia.wiki
Report outdated infoHelp us keep this page accurate