LangChain pricing

About

LangChain is the company behind the most-adopted open-source LLM application framework (launched October 2022 by Harrison Chase) and LangGraph, its agent-orchestration library (January 2024). Both frameworks are free. The business sits one layer up: the LangSmith platform — observability, evaluation, agent deployment, the no-code Fleet builder, the autonomous Engine debugger, and Sandboxes for agent-generated code — all sold from a single pricing page.

The funding arc tracks the monetization arc. A $10M Benchmark seed (April 2023) funded pure OSS distribution; the $25M Sequoia Series A (February 2024, ~$200M valuation) landed the same month LangSmith — the first paid SKU — hit general availability; and the $125M IVP-led Series B (October 2025, $1.25B valuation, with Databricks, Datadog, Cisco, ServiceNow, and Workday participating) coincided with consolidating every commercial product under the LangSmith brand.

This entry covers LangChain’s company-level monetization: the OSS strategy, deployment pricing, and the 2026 multi-SKU expansion — including the July 2026 restructure that collapsed the platform’s per-service rate cards into two normalized billing currencies, the LangChain Compute Unit and the LangChain Storage Unit. For a deep dive on the seats-plus-traces observability pricing specifically, see the LangSmith blueprint.

Pricing summary : How LangChain’s pricing model works

LangChain runs a textbook open-core funnel with a usage-metered top. The frameworks that made the company famous cost nothing; the hosted platform charges a per-seat subscription — Developer ($0, maximum 1 seat), Plus ($39/seat/mo, unlimited seats), Enterprise (custom, annual invoice) — and, since July 2026, settles all platform usage in two normalized units rather than a per-service rate card. This is a hybrid seat-plus-usage model with a credit-style abstraction layer on the usage half:

• The two currencies — 1 LCU (LangChain Compute Unit) = $1.50, “a normalized unit of work done on the LangSmith Platform” covering compute, tokens and processing; 1 LSU (LangChain Storage Unit) = $1.00, “a normalized unit of data stored or managed”. Each service converts into one or both at its own rate.
• Observability & Evaluation (traces) — 5k (Developer) or 10k (Plus) base traces/mo included, then pay-as-you-go at 0.005 LSU per additional trace. Base traces are retained 14 days; extended traces are retained 180 days for an additional fee. Covered in depth on the LangSmith page.
• Deployment — Plus includes 1 free Serverless (Small) deployment. Additional Serverless and Dedicated deployments come in Small, Medium and Large sizes and are charged on resources consumed: runtime compute 0.045 LCU/vCPU-hr, runtime memory 0.006 LCU/GiB-hr, database compute 0.177 LSU/vCPU-hr, database memory 0.025 LSU/GiB-hr. Deployment is not available on Developer.
• Fleet (no-code agents) — metered in LCUs, with 5 LCU/mo included free on Developer and 25 LCU/mo included on Plus; on Developer, Fleet pauses new runs once the allowance is spent until it resets or the org upgrades. Model costs are included (Fast / Pro / Max tiers), but every Fleet run is also traced and counts toward trace billing.
• Engine (autonomous agent-fixing) — metered in LCUs, model usage included; an Engine run consumes roughly 5–30 LCUs and Engine is scheduled to run once every 6 hours. Not available on Developer; on Enterprise, LCUs draw against committed LangChain credits.
• Sandboxes (isolated compute for agent-generated code) — compute 0.0384 LCU/vCPU-hr, memory 0.0123 LCU/GiB-hr, storage 0.000123 LSU/GiB-hr, all billed per second. Both Developer and Plus include 5 LCU and 1 LSU of sandbox usage per month free; Developer is limited to 10 sandboxes.

What makes this different: most AI-infra companies pick one value metric, and LangChain briefly went the other way — a distinct meter per product (traces, deployment runs, uptime minutes, Fleet runs, LCUs). The July 2026 restructure reversed that: seven meters collapsed into two currencies under one stable $39 seat anchor, so a new product now ships as an LCU/LSU conversion rate rather than a new line on the rate card.

Pricing by product

LangSmith platform (plans)

Normalized billing units

Per-service metering rates

Sales motions across products: self-serve / PLG for Developer and Plus (monthly billing, seats pro-rated, usage in arrears), sales-led for Enterprise (annual upfront invoice, committed LangChain credits, infosec review, custom terms). A separate Startup Plan offers discounted rates and “generous free trace allotments” to early-stage companies, by application. The OSS frameworks remain a zero-price acquisition channel feeding all of it. For a primer on picking meters like these, see choosing the right usage metric.

Hidden costs : What LangChain users actually pay

The $39 seat is the smallest number on the page. A five-person team on Plus running one always-on Dedicated agent at moderate volume — 150k traces and 100k invocations a month — under the July 2026 unit structure:

LangChain publishes vCPU and GiB specs per deployment size in its docs rather than on the pricing page, so the deployment lines above model a 1 vCPU / 2 GiB profile.

Under the June 2026 rate card the same team paid roughly $1,201 — $350 of traces, $156 of standby uptime and $500 of per-run charges. The headline total barely moved; the composition inverted. Four mechanics explain why:

1. Throughput got free, persistence got expensive. The $0.005-per-run charge is gone, so 100k invocations now cost nothing directly. In exchange, an always-on deployment bills resource-hours whether or not it runs anything: the same profile that cost $156/month of standby now costs ~$228 in runtime plus database. Break-even for this archetype sits near 14,000 runs/month — above it the restructure is a discount, below it a price rise.
2. The database is the new parking meter. LangChain’s own FAQ defines uptime as “the duration your deployment’s database is live and persisting state,” and that is exactly where the meter went. Database compute at 0.177 LSU/vCPU-hr costs $0.177/vCPU-hr against $0.0675 for runtime compute — persistence is priced ~2.6× the work it persists, and it is the single largest deployment line in the table above.
3. Traces were normalized to the top of the old band. At $1.00/LSU, 0.005 LSU per trace is $5.00 per 1,000 — the ceiling of the previous $2.50–$5.00 range. Any team that had been billing at the low end of that band sees its largest variable line roughly double, with no headline price change to point at.
4. Engine’s forecast band got wider, not tighter. The published range moved from 10–15 LCUs every 6 hours to ~5–30 LCUs per run on the same 6-hour schedule — roughly $900–$5,400/month at $1.50/LCU. The floor halved and the ceiling doubled, so Engine remains the line most capable of exceeding every other line combined.

The free plan has the same shape. A solo user on Developer at 40k traces/month:

So a “$0” plan can invoice more than four Plus seats ($156) before the user has bought anything, because traces are the only meter Developer leaves uncapped — Fleet and Sandboxes stop rather than overflow.

Want to estimate your own LangChain bill? Use the LangChain pricing calculator to model seats, traces, and deployment resource-hours.

Pricing evolution : LangChain pricing history and changes

Cadence

Tracked range: 2024 Q1 – 2026 Q3. Quarters not listed above were verified stable (0 price changes, 0 SKU additions). The $39 seat has never moved; all evolution happens on the usage axes.

Notable changes

• 2024-02 — LangSmith GA establishes the $0 / $39-seat / custom structure that still anchors the page today (company history).
• 2024-06 — LangGraph Cloud beta announced with LangGraph v0.1; deployment monetization begins, off-page.
• 2025-05-14 — LangGraph Platform GA puts deployment pricing on the public page: $0.001 per node executed plus standby ($0.0036/min production, $0.0007/min dev); free self-hosted Lite tier with 100k nodes/mo.
• 2025-10 — $125M Series B at a $1.25B valuation; LangGraph Platform → LangSmith Deployment, LangGraph Studio → LangSmith Studio. Every paid SKU now carries the LangSmith brand.
• 2025-11 → 2026-01 — The quiet repricing: per-node-executed billing replaced by a flat $0.005 per deployment run. Nodes and subgraphs within one invocation are no longer charged separately; an interrupt resume counts as a new run.
• 2026-03 — Agent Builder rebrands to LangSmith Fleet ($0.05/run beyond plan allotments); Sandboxes enter private preview.
• 2026-05 — Interrupt 2026: Engine launches at $1.50/LCU; Sandboxes reach GA with per-second compute billing.
• 2026-07-21 — The seven-meter rate card collapses into two normalized currencies: 1 LCU = $1.50 for work and compute, and a newly introduced 1 LSU = $1.00 for traces and storage. Per-run deployment billing ($0.005) and uptime minutes ($0.0036/min production, $0.0007/min dev) are retired in favour of resource metering; Fleet leaves per-run pricing for LCU allowances; a LangSmith Usage Calculator lands on the pricing page. Seats hold at $0 / $39 / custom.

The two-unit restructure in detail

The July 2026 change is the largest single edit LangChain has made to its rate card, and it moves in the opposite direction from every prior change. Between 2024 and mid-2026 the page accumulated a meter per product — traces per thousand, deployment runs, uptime minutes, Fleet runs, Engine LCUs, three per-second sandbox rates. The restructure keeps every one of those services but stops pricing them in their own dimensions: each now publishes a conversion rate into LCUs (work and compute) or LSUs (data stored and managed), and only those two carry a dollar price.

Three consequences are worth separating from the announcement:

• The deployment meter changed for the third time in fourteen months. Per-node-executed (May 2025) became per-run (January 2026) became resource-hours (July 2026). Each revision moved the unit further from something a buyer can count in advance: nodes were readable from your own graph, runs matched invocations, and vCPU-hours require knowing a deployment size that is documented off-page. Any forecasting model built on the January per-run unit is now obsolete after roughly six months of life.
• Uptime was renamed, not removed. The retired $0.0036/min standby charge priced a deployment’s persistence; database compute at 0.177 LSU/vCPU-hr does the same job in the new currency, and LangChain’s own FAQ still defines uptime as the duration the deployment’s database is live. The economics inverted for throughput-heavy users (per-run charges are gone) and worsened for idle always-on agents.
• The calculator is the load-bearing half of the release. Two currencies do not by themselves make a seven-service bill composable — the buyer still needs to stack Observability, Engine, Deployments, Sandboxes and Fleet. Shipping the interactive estimator, with a share-by-link button and an explicit “Estimate only” caveat, in the same release is what turns the abstraction into something a team can put in a budget. It closes the exact gap this page flagged in June 2026.

What LangChain did not do is publish a migration comparator. No surface shows an existing customer their June bill restated in LCUs and LSUs, and the trace reprice in particular — 0.005 LSU is $5.00 per 1,000, the top of the previous $2.50–$5.00 band — arrives without a headline price change to point at.

What’s unique : LangChain’s distinctive pricing mechanics

1. The brand inversion, now complete. The famous name is the free thing. LangChain and LangGraph (the frameworks) cost nothing and cap nothing; 100% of monetization flows through the LangSmith brand. Since July 2026 the only place the word “LangChain” appears on a paid invoice is inside the unit names — LangChain Compute Units and LangChain Storage Units. The company name survives on the bill as a currency, not as a product.

2. Two currencies, not one credit. Almost every vendor that abstracts a multi-service rate card collapses it into a single credit. LangChain kept a split: 1 LCU = $1.50 for work done, 1 LSU = $1.00 for data held. That separation is a deliberate pricing statement — it says agents cost money in two structurally different ways, and it keeps the persistence half of an agent’s cost visible instead of blending it into an undifferentiated pool. The trade is that a buyer must forecast two balances instead of one.

3. The same product billed in both currencies at once. A deployment’s runtime is metered in LCUs (0.045 LCU/vCPU-hr) while the database behind it is metered in LSUs (0.177 LSU/vCPU-hr). One deployment, two units, one invoice — and the storage side is the larger of the two at equivalent size. This is the closest thing in the agent-infra category to explicitly pricing statefulness as its own line item, which is what long-running agents actually are.

4. Three deployment meters in fourteen months, each less countable than the last. Per-node-executed (May 2025) → per-run (January 2026) → resource-hours in LCU/LSU (July 2026). Runs were the most buyer-legible unit LangChain ever shipped and lasted about six months. The direction of travel is consistent: units keep moving from things a buyer can count before the bill arrives to things only the vendor’s meter can total afterwards.

5. The unit absorbs model costs. Fleet and Engine both bill in LCUs with the underlying provider tokens included, and LangChain manages model access for the Fast / Pro / Max tiers so buyers don’t bring their own API key. That is unusual: the vendor takes the token-price and model-mix risk in exchange for a more opaque unit. It removes one bill from the buyer’s stack — Fleet’s old “$0.05/run plus traces plus your own LLM spend” is now “LCUs plus traces” — while making the margin on each LCU entirely LangChain’s to manage.

Strengths & weaknesses

Billing UX : LangChain billing controls and transparency

• LangSmith Usage Calculator — an interactive estimator now sits on the pricing page itself. Buyers compose an “agent stack” by adding product modules (Observability & Evals, Engine, Deployments, Sandboxes, Fleet), set a traces-per-month slider (0 to 1m) and a seat stepper, and get a per-module subtotal, a share-of-total bar, and a sticky Monthly total bar that breaks the estimate into LCU, LSU and dollars. A Copy Estimate Link button shares the configured estimate with colleagues.
• Published unit conversion — the two currencies are stated on the page as flat prices (1 LCU = $1.50, 1 LSU = $1.00) and every service publishes its own conversion rate (e.g. “0.005 LSU / additional trace”, “Compute · 0.0384 LCU / vCPU-hr”), so a buyer can reconstruct any line by hand. The calculator carries the caveat verbatim: “Estimate only. Actual LCU/LSU consumption varies with the work your agents perform.”
• Billing console (Settings > Billing) — organization LCU usage is visible in the LangSmith billing console, and the Plans and Billing page is where a Developer account self-serve upgrades to Plus.
• Engine spend limits and kill switch — an Organization Admin can cap Engine consumption with a Monthly LCU spend limit, set either org-wide (Settings > Engine enablement) or per tracing project; limits are entered in LCU or USD (1 LCU = $1.50), and LangSmith pauses new Engine runs once a limit is reached until it is raised or the next monthly billing period begins. Month-to-date Engine LCU spend is visible per organization and per project. An admin can also turn Engine off outright, after which it stops running on its 6-hour schedule and consumes no LCUs.
• Billing mechanics — Seats bill monthly on the 1st, pro-rated when added mid-month (no credit for removed seats); traces bill monthly in arrears. Enterprise is invoiced annually upfront with custom terms, and LCU usage is charged against committed LangChain credits rather than billed as an add-on.
• Allowance behaviour differs by plan — Fleet’s included allowance is an enforced stop on Developer (new runs pause until the monthly reset or an upgrade) but a soft threshold on Plus (additional usage is simply billed). Sandbox TTLs are configurable so inactive sandboxes shut down automatically rather than accruing per-second charges.
• Payment and procurement — card-based, monthly self-serve for Developer and Plus; annual invoice, custom terms and infosec review on Enterprise. A separate Startup Plan (application-based) offers discounted rates and free trace allotments to early-stage companies.

Strategic wins : Why LangChain’s pricing decisions worked

1. Sequencing the monetization ladder

LangChain monetized in the order its users matured: free frameworks built the audience (2022–2023), observability monetized debugging once apps hit production (2024), deployment monetized hosting once agents ran long (2025), and Fleet/Engine/Sandboxes monetized the post-deployment lifecycle (2026). Each SKU landed roughly when the installed base developed the problem it solves — and the July 2026 restructure is the same instinct applied to the rate card itself, arriving once the number of meters had become its own adoption barrier. See how AI companies structure pricing.

2. Consolidating seven meters into two currencies before adding an eighth

By June 2026 the pricing page carried a distinct unit for every product, and the complexity was compounding with each launch. The July 21, 2026 restructure stopped that: every service now publishes a conversion rate into LCUs or LSUs, so the next SKU ships as a rate rather than as a new meter. The structural win is that packaging complexity is now bounded — LangChain can keep expanding the platform without the rate card growing with it. Related: choosing the right usage metric.

3. Shipping the calculator in the same release as the abstraction

Two currencies alone would have made the bill shorter, not clearer — a buyer stacking Observability, Engine, Deployments, Sandboxes and Fleet still has to compose five conversion rates. Landing the LangSmith Usage Calculator on the pricing page in the same release, with per-module subtotals, an LCU/LSU/dollar split and a share-by-link button, is what makes the abstraction survivable. Vendors that abstract first and tool later spend the intervening quarters losing deals to “we can’t model the ceiling.” See bill shock and cost unpredictability.

4. Brand consolidation ahead of the bundle

Renaming LangGraph Platform to LangSmith Deployment (October 2025) looked cosmetic but was pricing infrastructure: it let the 2026 SKU wave (Fleet, Engine, Sandboxes) launch as line items on one familiar bill rather than as separate products to procure — and positioned Enterprise’s committed LangChain credits as a single drawdown pool across the whole stack. The two-unit restructure is that project’s second act: one brand, then one pair of currencies to spend inside it. See outcome-based pricing trends.

Areas to improve : Gaps in LangChain’s pricing approach

1. Publish deployment size specs on the pricing page

The July 2026 rates are quoted per vCPU-hour and per GiB-hour, but the vCPU and GiB counts behind Small, Medium and Large live in the docs — the page says only “specs by size can be found here.” That makes 0.045 LCU/vCPU-hr unusable as a dollar figure without leaving the pricing page, and it is the one input the new Usage Calculator most needs a buyer to already know. Publishing a three-row size table inline would make the deployment lines self-verifying, the same way the sandbox and trace rates already are. See choosing the right usage metric.

2. Show existing customers their old bill in new units

Traces moved from a $2.50–$5.00 per-1k band to a flat 0.005 LSU — $5.00 per 1,000 — and deployments moved from runs plus standby to resource-hours, all without a headline price change. A team on the old low end can see its largest variable line roughly double with nothing on the page explaining why. A migration comparator in the billing console, restating last month’s usage under both rate cards, would convert an unexplained increase into a defensible one — and it is exactly the artefact enterprise buyers ask for at renewal. Related: bill shock and cost unpredictability.

3. The LCU is a wider trust ask than it was

Normalization put the whole platform behind a vendor-defined unit, and the one place LangChain publishes an expected consumption figure — Engine — widened its band to “~5–30 LCUs” per run, roughly $900–$5,400/month on the default 6-hour schedule. Fleet publishes no LCU range at all beyond “varies by model tier.” A per-run LCU cap, or even a published median alongside the range, would let cost-sensitive teams leave Engine on and forecast it, rather than backstopping the range with a monthly spend limit or the kill switch.

4. Give Plus the spend ceiling Developer already has

Fleet on Developer proves LangChain can enforce a hard stop: 5 LCU, then runs pause until reset or upgrade. On Plus the same allowance becomes a soft threshold and everything above it is simply billed. The one paid-plan spend control LangChain does publish — the Monthly LCU spend limit that pauses new runs — is scoped to Engine alone; every other meter on Plus, traces included, runs uncapped. Extending that same limit into an account-wide LCU/LSU budget cap with alert thresholds would give paying teams the guardrail the free plan gets by default. See usage-based pricing strategy.

Key takeaways

1. Give away the name, sell the platform. LangChain’s frameworks are free marketing at planetary scale; every dollar flows through LangSmith — and the strategy survived the awkwardness of the paid brand differing from the company name.
2. Cap the number of meters, not the number of products. A rate card that grows a unit per launch eventually prices itself out of consideration. Normalizing into two currencies lets LangChain keep shipping SKUs while the pricing page stops getting longer — the abstraction is a packaging decision, not an accounting one.
3. Stateful agents need two axes, and the storage axis is the bigger one. Splitting work (LCU) from persistence (LSU) makes explicit what per-run pricing hides: at equivalent size, LangChain charges roughly 2.6× more per vCPU-hour to keep an agent’s database alive than to run its code. Long-running agent infrastructure prices like a database, not like an API.
4. Abstraction is only safe if you ship the tooling with it. LangChain landed a whole-stack estimator, per-service conversion rates and a share-by-link button in the same release as the two units. Abstracting first and tooling later is how vendors turn a simplification into a trust problem.
5. A stable seat anchor buys freedom on the usage axes. Holding $39/seat fixed since 2024 gave LangChain cover to add, rename, and twice re-base every usage meter beneath it — including a trace reprice to the top of the old band — without a single “price increase” headline.

UBP implications

1. Open-core AI infra monetizes the lifecycle, not the framework. The durable pattern — also visible at Helicone and across LLMOps — is a free core with paid meters attached to production pain: observability, deployment, and now autonomous maintenance.
2. Plan for two unit revisions, not one. LangChain changed its deployment meter twice in fourteen months — nodes to runs in January 2026, runs to resource-hours in July 2026 — because each unit that fixed a forecasting problem created a packaging one. Teams designing a v1 meter should assume the unit is a hypothesis with a shelf life, and build the metering pipeline to re-base rather than to hold.
3. Synthetic units scale only when every service publishes its conversion rate. Blended units simplify invoices but shift forecasting risk to the buyer, and the July 2026 restructure shows the compensating controls that make that trade survivable: a flat dollar price per unit, a published rate for each service that consumes it, an on-page estimator, and committed-credit drawdown on Enterprise. Where a rate is missing — Fleet publishes no LCU range, deployment sizes live off-page — the abstraction stops being verifiable. See usage-based pricing strategy.

Sources

• LangChain pricing page — live capture (accessed 2026-07-21)
• LangSmith pricing page — second surface serving the same rate card (accessed 2026-07-21)
• LangSmith docs — Engine: LCU costs and monthly spend limits (accessed 2026-07-21)
• LangSmith docs — usage and billing: trace retention tiers, rate limits and usage limits (accessed 2026-07-21)
• LangGraph Platform GA announcement, May 14 2025 (accessed 2026-06-10)
• LangChain changelog — LangSmith Deployment naming change (accessed 2026-06-10)
• Everything we shipped at Interrupt 2026 (accessed 2026-06-10)
• Archived snapshots of langchain.com/pricing — 2024-07, 2025-07, 2025-11, 2026-01, and the last pre-restructure capture on 2026-07-14 (accessed 2026-07-21)

Bottom line

LangChain runs the cleanest open-core ladder in agent infrastructure: free frameworks (LangChain, LangGraph) built a planetary funnel, and the LangSmith platform monetizes it with a $39 seat anchor unchanged since 2024. On July 21, 2026 the company did what its own rate card had been demanding — collapsed seven per-service meters into two normalized currencies, the $1.50 LangChain Compute Unit for work and the new $1.00 Storage Unit for data held, retired per-run and standby deployment billing for resource metering, and shipped a Usage Calculator so buyers can actually compose the result. It is a genuine simplification, and it is also the third deployment meter in fourteen months and a quiet reset of traces to $5.00 per 1,000 — the top of the old band. The direction is clear: pricing complexity moved off the page and into the unit, which is a better place for it only as long as every conversion rate stays published. For the observability half of the story, see the LangSmith blueprint.

Want to compare LangChain against other agent-infrastructure companies? Browse the pricing blueprint.

Pricing timeline : Major events on a vertical axis

Each milestone below corresponds to a public pricing change, product launch, or material adjustment. Major events use a filled marker; minor adjustments use a faded one.

Seven meters collapse into two units — LCU and LSU

Jul 2026

LangSmith replaces its per-service rate card with two normalized currencies: the LangChain Compute Unit (1 LCU = $1.50, for work and compute) and the new LangChain Storage Unit (1 LSU = $1.00, for traces and storage). Per-run deployment billing and uptime minutes are retired in favour of resource metering (0.045 LCU/vCPU-hr runtime compute, 0.177 LSU/vCPU-hr database compute) across Serverless and Dedicated deployments in Small/Medium/Large sizes; Fleet moves from per-run pricing to LCU metering with 5 LCU (Developer) or 25 LCU (Plus) included monthly; sandbox rates are restated in LCU/LSU. Seats hold at $0 / $39 / custom, and a LangSmith Usage Calculator lands on the pricing page.

Full agent-stack pricing verified — seven meters, one seat anchor

Jun 2026

Live capture: Developer $0 / Plus $39-seat / Enterprise custom, now spanning traces ($2.50–$5.00 per 1k), deployment runs ($0.005) + uptime, Fleet runs ($0.05 beyond 500/mo, rebranded from Agent Builder in March 2026), Engine at $1.50/LCU (Interrupt 2026 launch), and Sandboxes billed per second ($0.0576/vCPU-hr, $0.0185/GiB-hr memory, $0.000123/GiB-hr storage).

Deployment repriced — per-node-executed becomes $0.005 per run

Jan 2026

Wayback snapshots bracket a quiet metering change: November 2025 still shows $0.001 per node executed; by January 24, 2026 the page bills a flat $0.005 per deployment run (one end-to-end agent invocation — nodes and subgraphs no longer charged separately). Uptime minutes unchanged.

Series B unicorn round; LangGraph Platform renamed LangSmith Deployment

Oct 2025

LangChain raises $125M led by IVP at a $1.25B valuation and consolidates branding: LangGraph Platform becomes LangSmith Deployment and LangGraph Studio becomes LangSmith Studio, putting every paid SKU under the LangSmith umbrella. Headline prices unchanged ($39 seat, $0.001/node, standby minutes).

LangGraph Platform GA — per-node deployment pricing goes public

May 2025

LangGraph Platform reaches general availability with three deployment options (Cloud, Hybrid, Self-Hosted). Public metering: $0.001 per node executed plus standby uptime at $0.0036/min for production and $0.0007/min for development deployments; a free self-hosted Lite tier includes 100k nodes executed/month.

LangGraph Cloud beta — deployment as a product

Jun 2024

Alongside LangGraph v0.1, LangChain announces LangGraph Cloud in beta: managed infrastructure for deploying long-running, stateful agents. Deployment pricing is not yet on the public pricing page, which still shows only LangSmith seats and traces (Wayback, July 2024).

LangSmith GA — first paid SKU

Feb 2024

After a year of free open-source distribution (Oct 2022 launch, $10M Benchmark seed in April 2023), LangChain ships its first revenue line: LangSmith observability exits beta at $0 Developer / $39-seat Plus / custom Enterprise, the same month as the $25M Sequoia Series A (~$200M valuation).