LangGraph pricing in 2026: what you actually pay at scale

LangGraph pricing trips up most teams at the same point: you expect a single number and instead find two completely separate billing surfaces. The OSS library, released under the MIT license on GitHub, costs nothing and carries no usage ceiling. The paid layer is LangSmith, LangChain's observability and deployment product, which includes what LangChain calls "LangGraph Platform" (the managed runtime for deploying agent graphs to production). Understanding which layer you are actually paying for is the first decision that determines your monthly spend. This article breaks down both layers, compares the self-hosted and managed paths at concrete run volumes, and identifies the line items that catch teams off guard once they cross into production at scale.

LangGraph pricing: two layers most teams mix up

The LangGraph OSS library is available on GitHub under the MIT license. You can build, run, and deploy agent workflows locally or on your own infrastructure with no license fee and no usage reporting back to LangChain. The $0 figure is not a free tier with hidden caps. It's the standard baseline for anyone running the framework outside LangChain's cloud.

The paid surface enters when you add LangSmith. LangSmith is a separate product, tightly integrated with LangGraph, that handles tracing, evaluation, and production deployments. "LangGraph Platform" is the branded name for the managed agent runtime inside LangSmith, not a standalone product you purchase independently. The LangChain pricing page documents this structure, but the naming overlap between the open-source framework and the managed platform generates persistent confusion in developer communities.

As of 2026, the entry point for the managed tier sits at $39 per seat per month on the Plus plan. The Developer plan is free and covers 5,000 traces per month. The confusion around langgraph pricing (and most of the "how much does LangGraph actually cost" questions you see in community threads) traces back to this structural split between a free OSS framework and a paid deployment platform that shares the same name.

LangSmith plan breakdown: Developer, Plus, and Enterprise

Three tiers are available as of 2026:

Plan	Seat cost	Traces included	LangGraph Platform access
Developer	$0/seat	5,000/month	1 Dev deployment
Plus	$39/seat/month	10,000/month	Production deployments
Enterprise	Custom	Custom	Custom SLA, SSO, audit logs

A "trace" in LangSmith represents one complete agent run logged end-to-end, including all intermediate node calls, LLM invocations, and tool executions. If your agent graph processes a user query through 8 nodes and calls an LLM 3 times, that counts as one trace with multiple spans. Monthly volume projections depend on how many agent runs you trigger per day, not on graph complexity alone.

The Developer plan is workable for solo developers building and iterating. The seat multiplier on Plus compounds quickly for engineering teams: five engineers needing LangSmith access costs $195/month in seats before any run or node fees. Ten engineers bring that to $390/month. Adding QA engineers and ML engineers later in a project lifecycle is where LangSmith billing surprises teams the most.

Enterprise pricing is not published publicly. Contracts at that tier add SSO, custom data retention, audit logs, and dedicated support SLAs. Negotiation typically involves committing to annual spend.

How LangGraph Platform charges per run and per standby minute

Dev deployment vs production deployment

The Developer plan includes one free Dev deployment with unlimited runs on that single instance. "Dev deployment" is a non-production environment designed for testing and iteration, not for serving live users under load. Moving a graph into production requires a Plus or Enterprise plan, at which point managed agent runtime fees apply to every production deployment you create.

Production billing runs on two meters: a per-run fee of $0.005 per agent run and a per-node execution fee of $0.001 per node executed across all runs. Both fees apply per production deployment.

Concrete illustration: a graph with 10 nodes running 2,000 times per month generates 20,000 node executions. Per-node execution pricing: $20. Run fees: 2,000 x $0.005 = $10. Total before standby and seat costs: $30/month. Scale to 20,000 runs on the same 10-node graph and the figure reaches $300 in node charges plus $100 in run fees before any standby component.

Standby billing: the line item teams miss

Always-on deployments (agents that must respond within milliseconds rather than cold-starting on each request) incur standby-minute charges for the compute time the runtime keeps warm between invocations. Teams running batch jobs that tolerate cold starts avoid standby charges entirely by shutting down deployments between scheduled job windows. This single adjustment can cut infrastructure costs materially for workloads that are not latency-sensitive.

Self-hosting LangGraph vs the managed platform: a cost comparison

For a team running 50,000 agent runs per month, managed platform billing breaks down roughly as follows: 50,000 runs x $0.005 = $250 in run fees, plus 500,000 node executions (10-node graph) x $0.001 = $500 in per-node execution pricing. Add Plus seats for five engineers at $195/month. Total estimated managed cost: approximately $945/month, excluding standby charges.

The self-hosted agent framework cost looks different. A 4-core, 8 GB RAM VPS sufficient to handle 50,000 light-to-medium agent runs per month runs $80 to $120/month on most cloud providers. Per-run and per-node fees disappear entirely. The replacement is ops overhead: deployment infrastructure, auth, horizontal scaling for peak loads, and wiring your own observability stack. A small team typically spends 4 to 8 hours per month on that maintenance.

At a $100/hour engineering rate and 6 hours of ops time, self-hosted infrastructure costs roughly $700/month all-in versus approximately $945 managed. The gap widens as run volume increases. The managed path wins on time-to-production for teams without dedicated infrastructure capacity. Self-hosting wins on raw cost above a threshold that depends on your specific graph depth and monthly run volume.

One clarification worth flagging: self-hosting LangGraph eliminates LangGraph Platform fees but does not include LangSmith tracing automatically. You can still route traces to LangSmith's cloud endpoint from a self-hosted agent, in which case standard trace volume billing applies under your LangSmith plan tier. Which is honestly a bit confusing if you're not expecting it.

Where costs spike in production and how to control them

Three billing drivers account for most unexpected bills, based on community reports including a 2025 Reddit r/LangChain discussion where multiple teams described managed agent runtime fees as opaque before they understood the per-node model:

Deep graphs with high node counts generate the most node execution charges. A 20-node graph running 5,000 times per month produces 100,000 node executions, adding $100 to the monthly bill in node fees alone. Auditing graphs to remove redundant intermediate steps is the most direct lever. Each node eliminated saves $0.001 per run, which compounds significantly at production volume.

Long standby windows accumulate charges even during off-hours with zero traffic. Scheduling automated shutdowns for development and staging deployments during non-business hours cuts this line item without meaningful workflow disruption for most teams. Production deployments that serve real users typically need to stay warm. Dev and staging environments rarely do.

Plus seat expansion happens gradually, as QA engineers, product managers reviewing agent traces, and ML engineers working on evaluation pipelines get added to the LangSmith organization. Scoping access to engineers who actively build and debug is the simplest way to control seat count. Teams crossing approximately 10,000 production runs per month typically see their first meaningful bill, based on where run fees and node fees begin to compound at standard graph depths.

Actually, that last point reminds me of something I saw at a previous gig. We had this one product manager who insisted on getting access to every tool the engineering team used, "for visibility." Six months later, we're paying seat licenses for tools he logged into exactly once. C'est la vie.

Key takeaways

Three decisions determine what you actually pay. The OSS LangGraph library has no cost. Fees begin only with LangSmith observability or LangGraph Platform production deployments. The Developer plan ($0) covers development and testing up to 5,000 traces per month. Plus ($39/seat/month) unlocks production deployments with per-run and per-node billing layered on top. The self-host versus managed decision hinges on ops bandwidth as much as on raw billing math, typically favoring self-hosting above 30,000 to 50,000 monthly runs for teams with infrastructure capacity to absorb it.

---

LangGraph's real cost lives in LangSmith's per-run and per-node fees, not the OSS library. The demo-vs-product checklist in the kit shows you how to catch billing surprises before they hit production, including rate limiting to avoid those $800 LLM bills.

→ Get the welcome kit