LangGraph Pricing: A Complete Breakdown for 2026

LangGraph has become one of the most popular frameworks for building long-running AI agents. Built by the creators of LangChain, it provides durable execution, checkpointing, human-in-the-loop workflows, and stateful orchestration.

LangGraph pricing confuses people for a simple reason: LangGraph the framework doesn't cost anything. It's open source, and you can build and run agents with it for free. What actually shows up on an invoice is everything around it, mainly LangGraph Platform for hosting and LangSmith for tracing and evaluation. If you're trying to budget for a production agent built on LangGraph, this is the guide that separates what's free from what isn't.

This is written for engineering teams evaluating LangGraph before committing real budget to it, whether that's a platform lead scoping a build-vs-buy decision or a developer trying to explain the eventual bill to a manager.

What's included vs what costs extra

The free tiers are genuinely usable for prototyping. Where teams can run into additional costs is when they move from a few experiments to sustained production traffic.

Trace volume is one of the first things to watch. LangSmith Plus includes 10,000 base traces per month, after which trace usage is billed on a pay-as-you-go basis. A trace represents a single execution of an application and can contain many individual events, including LLM calls and tool calls. For agents generating large numbers of executions, usage can therefore grow quickly beyond the included allowance.

Retention is a separate consideration. Base traces are retained for 14 days, while extended traces can be retained for 400 days. Extended retention is useful for long-term debugging, evaluation, and analysis, but comes with an additional charge. LangSmith also lets teams selectively upgrade traces rather than retaining everything for the longer period.

Seats are charged per user. LangSmith Plus costs $39 per seat per month, so a five-person platform team would pay $195/month before usage-based charges. The Plus plan includes 10,000 base traces per month and one free small serverless deployment, with additional deployment resources billed based on usage.

Deployment and compute can add another layer of cost. LangSmith Deployment is included with Plus through one free small serverless deployment, but additional serverless or dedicated deployments are metered based on the resources they consume. Engine, Fleet, and sandbox usage are also metered separately through LangChain Compute Units (LCUs) and Storage Units (LSUs).

Self-hosting LangGraph itself is different. The open-source LangGraph framework has no license fee, but you're responsible for the infrastructure around it: compute, storage, monitoring, observability, credentials, and the operational work required to keep production agents running. The framework being free doesn't make the production stack free.

Does LangGraph Cost Money?

Yes, but it depends on which part of the LangGraph ecosystem you're using. The core LangGraph framework is free and open source under the MIT license. You can build AI agents with it and run them on your own infrastructure without paying LangChain a licensing fee.

The costs come in when you add managed services. LangChain's hosted deployment offering, formerly called LangGraph Platform, is now part of LangSmith Deployment. LangSmith's Plus plan starts at $39 per seat per month and includes access to Deployment, along with other LangSmith capabilities. Additional deployment and usage are billed based on the resources your agents consume.

LangSmith also provides observability, evaluation, debugging, and other agent-development capabilities. Its Developer plan is free for one seat with up to 5,000 base traces per month, while the Plus plan includes 10,000 base traces per month before usage-based charges apply.

So while LangGraph itself doesn't cost anything, running LangGraph agents in production can involve costs for deployment, compute, storage, tracing, evaluations, and model usage. If you self-host the open-source framework, you avoid LangChain's platform fees but take responsibility for operating the underlying infrastructure yourself.

LangGraph pricing plans

LangGraph itself is free and open source, but LangChain offers additional services for teams that want managed deployment, observability, evaluation, and other production infrastructure.

At a high level:

• LangGraph (Framework) is free and MIT-licensed. You can use it to build and run agent workflows on your own infrastructure without paying a LangChain license fee.
• LangSmith provides observability, evaluation, debugging, and related agent-development capabilities. The Developer plan is free for one seat, while Plus costs $39 per seat per month and includes up to 10,000 base traces per month.
• LangSmith Deployment, formerly called LangGraph Platform, provides managed infrastructure for deploying and scaling agents. The Plus plan includes one free small serverless deployment; additional deployments are charged based on the resources they consume.

The right setup depends on whether you're experimenting with agents, deploying a few applications, or operating them at enterprise scale. For a self-hosted setup, the framework itself has no license cost, but you'll need to account for your own compute, storage, monitoring, and operational infrastructure.

Note: LangChain's pricing is usage-based beyond the included allowances, so there isn't a single fixed monthly price for running LangGraph agents in production.

LangGraph Open Source Pricing

The LangGraph framework is completely free to use and is released under the MIT License. There are no LangChain licensing fees for the open-source framework, and it can be used for commercial applications.

With the open-source framework, you can build agentic applications with capabilities such as:

• Stateful agent workflows
• Multi-agent orchestration
• Durable execution and checkpointing
• Human-in-the-loop workflows
• Persistence and memory
• Custom graph-based execution logic

This makes LangGraph useful for:

• Individual developers learning agent frameworks
• Startups building MVPs
• Research and experimentation
• Internal prototypes and proof-of-concepts
• Teams that want full control over their agent infrastructure

The important distinction is that free doesn't mean zero production cost. The LangGraph library provides the orchestration framework, but when you self-host it, you're responsible for the infrastructure around it: compute, storage, databases, monitoring, observability, security, deployment, and scaling. You'll also pay the underlying model providers for the tokens your agents consume.

For teams that don't want to operate this infrastructure themselves, LangSmith provides managed services for observability and deployment. LangSmith Deployment is specifically designed to run long-running, stateful, and bursty agents with features such as durable execution, persistence, streaming, task queues, and horizontal scaling.

LangSmith Pricing

While LangGraph handles agent orchestration, LangSmith is LangChain's platform for tracing, debugging, evaluating, and monitoring LLM applications. It is available as a standalone developer platform and integrates closely with LangGraph for teams that want visibility into how their agents behave in production.

Free (Developer)

The Developer plan is designed for individual developers and small projects. It includes:

• 1 user seat
• Up to 5,000 base traces per month
• 14-day base trace retention
• Community support

Once you exceed the included trace allowance, usage is billed pay-as-you-go after adding a payment method.

For individual developers experimenting with LangGraph and LangSmith, this is generally enough to get started without a monthly subscription.

Plus

The Plus plan costs $39 per seat per month and is intended for teams building and deploying agents.

It includes:

• Up to 10,000 base traces per month
• Pay-as-you-go tracing beyond the included allowance
• Access to LangSmith Deployment, Engine, and other capabilities
• Unlimited seats at $39 per seat/month
• One free small serverless deployment

LangSmith's current usage-based pricing separates tracing from compute and storage. Base traces are charged at $0.0005 per trace, while traces retained for the extended 400-day period cost $0.005 per trace in total.

The extended-retention tier matters when you need traces for longer-term evaluation, debugging, or analysis. Base traces are retained for 14 days, while extended traces are retained for 400 days by default. Some features, such as adding feedback or running certain evaluators and automation rules, can automatically upgrade a trace to the extended tier.

Enterprise

The Enterprise plan uses custom pricing and is aimed at organizations that need advanced security, deployment, administration, and support capabilities.

It includes features such as:

• Self-hosted and hybrid deployment options
• Custom SSO, ABAC, and RBAC
• Support SLA
• Custom seats and workspaces
• Customizable extended retention policies

Organizations need to contact LangChain for Enterprise pricing.

Beyond the LangSmith subscription

It's also important to separate LangSmith's subscription price from the cost of running agents. LangSmith usage can include tracing, compute, and storage charges. The current pricing model uses LangChain Compute Units (LCUs) at $1.50/LCU and LangChain Storage Units (LSUs) at $1.00/LSU, with actual consumption depending on what your agents do.

LangSmith Deployment also has its own usage-based charges. For example, deployed LangGraph agents are currently charged $0.005 per Deployment Run, in addition to deployment uptime costs.

So the cost of using LangGraph in production isn't simply the $39 Plus subscription. Your total bill can include seats + traces + extended retention + compute + storage + deployment usage, in addition to the underlying LLM API costs.

Total cost of ownership considerations

The sticker price is only one part of the cost. Once you run LangGraph agents in production, you also need to account for the infrastructure and operational work around them.

With a self-hosted LangGraph deployment, you're responsible for the underlying compute, databases, storage, networking, monitoring, and scaling. If you use LangSmith for observability and managed deployment, those services introduce their own seat, tracing, compute, storage, and deployment usage costs on top of your LLM provider bill.

There's also the infrastructure around the tools your agents call. For example, agents using MCP servers or internal APIs may require separate systems for credential management, access control, rate limiting, auditability, and per-agent cost tracking. These aren't necessarily part of the LangGraph framework itself, so teams may need to build or integrate those capabilities separately.

This is where platforms such as TrueFoundry Agent Harness take a broader approach. Instead of treating the agent runtime, model access, MCP tooling, and observability as separate pieces, TrueFoundry brings these capabilities together in a single control plane. Teams can manage model access, MCP credentials and governance, agent execution, sandboxing, approvals, and observability from the same platform.

For teams running a handful of agents, managing these components separately may be perfectly reasonable. As the number of agents, models, users, and environments grows, however, the operational cost of stitching these systems together can become a meaningful part of the total cost of running LangGraph in production.

TrueForge: An Open-Source Runtime for AI Agents

TrueForge is the runtime layer that turns an LLM into a working agent, with MCP tools, skills, sandboxing, approvals, and subagents built in. It is an open-source agent harness with three parts: a core server that runs the agent loop, an HTTP API and TypeScript SDK for driving agents from code, and a chat UI with a React UI SDK for interacting with agents from the browser.

Getting started takes one command: npx @truefoundry/trueforge runs TrueForge locally with no additional infrastructure. The quickstart documentation walks through choosing a model provider and connecting your first MCP server.

Unlike a framework where you assemble the runtime and surrounding infrastructure yourself, TrueForge includes several of the pieces needed to run agents in production:

• A chat UI, bundled with the server, so you have an interface for interacting with agents without needing a separate hosted platform.
• Built-in observability, tracing model calls, tool calls, and agent steps as part of the runtime.
• An HTTP API and TypeScript SDK, so agents running through the chat UI can also be driven programmatically.
• Bring-your-own models, MCP servers, and sandbox providers, keeping the model and infrastructure layer separate from the agent runtime.

One architectural detail worth calling out is how TrueForge handles sandboxing. Rather than running the entire agent inside a sandbox, TrueForge treats the sandbox as a tool and provisions one only when the agent actually needs to execute code. This allows a single TrueForge server to run multiple agents concurrently, while avoiding sandbox overhead for turns that don't require code execution.

The architecture also has a direct impact on cost. In TrueFoundry's benchmark of 14 enterprise agent tasks, TrueForge and Claude Managed Agents achieved roughly the same task accuracy when both used Opus 4.8, while TrueForge used about 40% as many tokens and was roughly 30% cheaper per run. When paired with GLM-5.2, TrueForge achieved the same approximate task score for $2.90 per run versus $11.80 for Claude Managed Agents, or roughly 75% lower cost.

The entire runtime is MIT licensed and open source, with the code available in the TrueForge GitHub repository. For teams evaluating LangGraph pricing, the important distinction is that TrueForge provides the runtime layer itself, while keeping model choice, infrastructure, and deployment under your control.

Run AI Agents With More Control and Lower Costs

Build and run production-ready agents with TrueForge, an open-source runtime for your models, MCP tools, and infrastructure.

View on GitHub

Read the Docs

Conclusion

LangGraph is a flexible framework for building stateful, multi-step agents, but the cost of running those agents depends on more than the framework itself. Model usage, tool calls, observability, infrastructure, and the runtime layer can all contribute to the final bill.

TrueForge takes a different approach by providing the runtime layer as an open-source, model-agnostic agent harness. It includes the core agent loop, MCP tools, sandboxing, approvals, context management, observability, APIs, and a chat UI, while letting teams choose their own models and infrastructure.

For teams that want the flexibility of an open-source agent stack without having to assemble and operate every piece of the runtime themselves, TrueForge is worth considering. It gives you control over how agents run, which models they use, and how much the overall system costs.

FAQ

Is LangGraph pricing free?

‍LangGraph the framework is free and open source. You only pay if you use LangGraph Platform for hosted deployment (from $35/month) or LangSmith for tracing and evaluation (free tier available, $39/seat/month for Plus).

What does LangGraph cost for production use?

‍For a small team, LangSmith Plus plus LangGraph Platform runs somewhere between $75 and $150 a month, before LLM API costs and before trace overage. Larger teams with more seats or higher trace volume should expect that number to climb well past it.

Is LangSmith required to use LangGraph?

‍No. LangGraph runs fine without LangSmith. You lose the built-in tracing and evaluation dashboard, so most teams running anything beyond a prototype end up adopting some observability layer, whether that's LangSmith or something else.

Does TrueFoundry support MCP and AI agents?

‍Yes. TrueFoundry includes an MCP Gateway, an Agent Gateway, and an MCP and Agents Registry with tool-level access control. Agents built on LangGraph, CrewAI, AutoGen, or custom frameworks can be deployed and governed through the same control plane.

Does TrueFoundry integrate with my existing observability stack?

‍Yes. The platform is OpenTelemetry-compliant and plugs into Grafana, Datadog, Prometheus, or whatever you're already running, tracing each request from prompt through tool and model execution.