LangGraph Platform GA: Studio v2, One-Click Deploy Guide

Why This Matters

Shipping a LangGraph agent to a development laptop is one thing. Getting it into production — with persistent state, human-in-the-loop gates, reliable retries, and a debugger that does not require a macOS desktop app — is a different problem entirely.

That problem got a cleaner answer on May 14, 2026, when LangChain announced that LangGraph Platform had reached General Availability. The announcement came alongside Studio v2, a browser-based visual debugger that replaces the earlier desktop application. Nearly 400 companies had been running the platform during the beta period, including Klarna, Uber, and LinkedIn.

The timing also matters because the competitive landscape for agent infrastructure shifted in early 2026. Microsoft moved its AutoGen project into maintenance mode, redirecting investment toward the Microsoft Agent Framework. That left LangGraph and CrewAI as the two active frameworks with genuine production traction. LangGraph's stated differentiator is durable execution: graph-based state control, automatic checkpointing, and a managed runtime that handles the infrastructure layer so the agent code does not have to.

This guide covers what the platform is, what Studio v2 adds, how the deployment model works, and where it fits relative to the alternatives.

What Is LangGraph Platform?

It helps to separate two things that share the name "LangGraph":

The open-source library is an MIT-licensed Python framework for building stateful, cyclical agent workflows as explicit directed graphs. It reached its 1.0 stable release in October 2025, which included an API stability guarantee — no breaking changes until a 2.0 release. This is the library developers install via pip install langgraph. It is free and has no usage caps.

LangGraph Platform (also referred to as "LangSmith Deployment" in LangChain's documentation after an October 2025 rebrand) is the managed infrastructure layer that sits on top of that library. It handles deployment, autoscaling, persistence, task queuing, and observability. It is what you pay for if you want LangGraph agents running in production without managing your own infrastructure.

The naming situation is genuinely confusing. After the 1.0 release, LangChain unified three product pillars under the LangSmith brand — Observability, Evaluation, and Deployment — and renamed LangGraph Platform to "LangSmith Deployment." However, the May 2026 GA announcement still used the "LangGraph Platform" name in the blog URL and official changelog. Both names appear in active documentation as of mid-2026. The safest mental model: LangGraph (lowercase) is the open-source framework; LangGraph Platform / LangSmith Deployment is the paid hosting layer.

The platform adds four capabilities that the open-source library does not include:

• Managed persistence: conversations, thread history, and state are saved automatically. No custom database logic required.
• Durable execution: if a server restarts mid-workflow, the agent resumes from the last checkpoint.
• Built-in task queuing: background runs, cron scheduling, and webhooks are first-class platform primitives.
• Production autoscaling: containers scale based on CPU utilization and pending run queue depth.

Studio v2: Browser-Based Visual Debugging

The most visible change in the May 2026 announcement is Studio v2. The prior version required a macOS desktop application. Studio v2 runs in the browser.

You start a local Studio session with:

langgraph dev

That command starts a local server and opens Studio v2 in the browser at localhost:8123 by default. No desktop installation required.

What Studio v2 Shows You

Graph rendering. Studio v2 renders your agent's execution graph visually — each node in the LangGraph definition appears as a node in the UI, with edges showing the conditional routing between them. As the agent runs, nodes highlight as they execute.

Per-node state inspection. At every node in the graph, you can inspect the full state object at that point in execution. This means you can see exactly what data the LLM received, what the tool returned, and what the state looked like when the routing decision was made.

Time-travel debugging. LangGraph's checkpoint system saves state at each node boundary. Studio v2 exposes those checkpoints as a timeline you can navigate. If an agent produces a wrong output at step seven, you rewind to step six, change an input or configuration value, and re-run from that point — without restarting the full workflow.

Production trace replay. This is the practical daily-use feature. You can pull a production trace from LangSmith — a real user interaction that failed or produced unexpected results — and replay it locally in Studio v2. You then edit the prompt or configuration and replay again, all without touching production code or triggering a redeploy.

Playground integration. Individual LLM calls within a trace can be opened directly in the LangSmith Playground. This means you can isolate a single prompt, experiment with model parameters, and test revisions before changing anything in the graph code.

What This Workflow Replaces

Before Studio v2, the common debugging loop looked like:

1. Agent fails in production.
2. Developer reads LangSmith traces in the text-based trace viewer.
3. Adds print statements or additional logging to graph nodes.
4. Redeploys.
5. Triggers the same scenario again.
6. Reads updated logs.

Studio v2 short-circuits steps 3 through 6. The state is already captured at every node. The trace is already stored. The developer pulls it into the browser and steps through it directly.

One-Click Deploy and Production Runtime

Deploying an Agent

From the management console, deploying a LangGraph agent to the managed cloud is a single action with native GitHub integration. The equivalent CLI path:

# Install the LangGraph CLI
pip install "langgraph-cli[inmem]"

# Create a new project from a template
langgraph new my-agent --template react-agent-python

# Deploy to LangGraph Platform
langgraph deploy

The langgraph deploy command packages the agent, pushes it to the managed runtime, and handles the rest. For local development, langgraph dev runs a local server that connects to Studio v2.

Autoscaling

The platform scales containers based on two signals:

• CPU utilization: target threshold of 75%. When CPU crosses that, a new container spins up.
• Pending run queue depth: target of 10 pending runs per container. One container with 20 queued runs triggers a scale-up to two containers.

API servers and agent servers scale independently. A spike in run submission requests — which hits the API server — does not slow down ongoing agent runs on the agent servers.

Scale-down has a 30-minute delay. After the delay, metrics are recomputed before a container is removed. This prevents thrashing during workloads with short bursts.

Background Runs, Cron, and Webhooks

LangGraph Server exposes native primitives for async execution:

# Submit a background run (non-blocking)
thread = await client.threads.create()
run = await client.runs.create(
    thread_id=thread["thread_id"],
    assistant_id="my-agent",
    input={"messages": [{"role": "user", "content": "Analyze this dataset"}]},
    multitask_strategy="queue"
)

# Schedule a recurring run with cron
cron = await client.crons.create(
    assistant_id="my-agent",
    schedule="0 9 * * 1-5",  # Weekdays at 09:00
    input={"messages": [{"role": "user", "content": "Daily market summary"}]}
)

Webhooks allow external systems to trigger agent runs on events. Combined with the persistence layer, this makes it practical to build agents that handle long-running tasks — research workflows that run for hours, document processing pipelines that wait on human approval, or scheduled reporting agents that fire on a timer.

Durable Execution and Human-in-the-Loop

If a worker restarts mid-execution, the agent resumes from the last checkpoint. This is handled by the platform's persistence layer, which uses Redis or PostgreSQL for checkpoint storage in production Kubernetes deployments.

Human-in-the-loop is a first-class API primitive. An agent can pause at a node, surface its current state for human review, and resume when approved — without polling, timeouts, or custom callback infrastructure:

from langgraph.graph import StateGraph, END
from langgraph.checkpoint.memory import MemorySaver

# The interrupt_before parameter pauses execution before the specified node
graph = builder.compile(
    checkpointer=MemorySaver(),
    interrupt_before=["human_review"]
)

# Resume after human approval
result = await graph.ainvoke(
    Command(resume={"approved": True}),
    config={"configurable": {"thread_id": thread_id}}
)

Real-Time Streaming

The platform streams LLM tokens, tool calls, state updates, and node transitions as they happen. For interactive applications, this means users see partial responses as the agent works:

async for chunk in client.runs.stream(
    thread_id=thread["thread_id"],
    assistant_id="my-agent",
    input={"messages": [{"role": "user", "content": "What happened in the market today?"}]},
    stream_mode=["messages", "updates"]
):
    print(chunk)

LangGraph Platform vs. Alternatives

A note on Temporal specifically: it is often positioned as a direct competitor to LangGraph Platform, but the relationship is more nuanced. Temporal handles durable orchestration at the infrastructure layer — it is good at keeping a workflow alive for days or weeks, surviving server restarts and worker rollouts. LangGraph handles agent reasoning at the application layer — cyclical tool use, dynamic routing, state accumulation across turns.

A pattern that appears in production stacks is using both: a Temporal workflow activity spins up a LangGraph agent as a subtask. Temporal owns the macro lifecycle; LangGraph owns the agent control flow within each task.

The key practical difference: LangGraph checkpointers survive within a deployment, while Temporal's state survives across worker rollouts and infrastructure events. If your agents run for minutes, LangGraph Platform's checkpointing is sufficient. If they run for hours or days across infrastructure changes, Temporal (or a hybrid) is worth evaluating.

Getting Started: Free Tier

The free path to LangGraph is the open-source library and the Developer self-hosted option.

Open-source library (no account required):

pip install langgraph langchain-anthropic

You get the full framework: stateful graphs, built-in checkpointing, human-in-the-loop, streaming, and LangGraph Studio v2 locally via langgraph dev.

Developer plan (free, self-hosted):

• Up to 100,000 node executions per month
• One free Developer deployment included
• Requires a LangSmith account (free tier available)
• Self-hosted: you manage the infrastructure

The managed cloud (where LangGraph Platform handles scaling, persistence, and infrastructure) requires the Plus plan. Plus requires a LangSmith Plus subscription, priced at $39 per user per month. Compute costs on Plus are billed per node executed ($0.001/node) plus standby time. Enterprise pricing is custom.

Note: third-party pricing summaries vary and some figures in secondary sources may reflect pre-rename billing units. For current pricing, the authoritative source is langchain.com/pricing.

To try Studio v2 locally with the free tier:

# Install CLI
pip install "langgraph-cli[inmem]"

# Create a project
langgraph new my-first-agent --template react-agent-python
cd my-first-agent

# Start local server with Studio v2
langgraph dev
# Opens browser at localhost:8123

From there you can build a graph, run it, and step through execution in the Studio v2 interface without any cloud account.

FAQ

Is LangGraph Platform the same as LangSmith Deployment?

Functionally, yes. In October 2025, LangChain rebranded the managed infrastructure product from "LangGraph Platform" to "LangSmith Deployment" as part of unifying three pillars under LangSmith (Observability, Evaluation, and Deployment). However, the May 2026 GA announcement retained the "LangGraph Platform" name in official blog URLs and the changelog, so both names appear in active documentation. For practical purposes, they refer to the same managed hosting product.

Do I need LangSmith to use LangGraph?

No. The open-source LangGraph library works without LangSmith. LangSmith is LangChain's observability and evaluation platform — it provides tracing, the Studio v2 debugger at scale, and the managed deployment product. If you are self-hosting and want tracing, LangSmith has a free tier. If you want the managed cloud runtime, you need a LangSmith Plus or Enterprise account.

How does LangGraph's checkpointing compare to Temporal's durable execution?

LangGraph checkpointers save state at each node boundary within a deployment. If the agent server restarts, the agent resumes from the last checkpoint. Temporal's durability model survives across worker rollouts and infrastructure changes — state persists even if the entire worker pool is replaced. For agents that run for minutes to an hour, LangGraph Platform's built-in checkpointing is sufficient. For workflows that run for hours or days across infrastructure events, Temporal offers stronger durability guarantees. Many production teams use both together.

What happened to LangGraph Studio v1 (the desktop app)?

Studio v1 required a macOS desktop application. Studio v2 is entirely browser-based — access it by running langgraph dev and navigating to the local URL it prints. The desktop app is no longer the recommended path. Some third-party guides still reference the desktop app; those reflect the pre-v2 setup.

Is the langgraph.prebuilt module still available in LangGraph 1.0?

The langgraph.prebuilt module was deprecated as of LangGraph 1.0 (October 2025). Its functionality moved to langchain.agents. If your code imports from langgraph.prebuilt, migration involves updating those imports. The 1.0 release carried a no-breaking-changes guarantee for the core API, but this deprecation is the notable exception to account for.

Key Takeaways

• LangGraph Platform reached GA on May 14, 2026, after nearly 400 companies used it in beta. Klarna, Uber, and LinkedIn are among the referenced enterprise users.
• Studio v2 eliminates the desktop app. The browser-based debugger lets you pull production traces, step through per-node state, replay checkpoints, and edit prompts — without a redeploy.
• The free tier covers serious development. The open-source library and self-hosted Developer plan (100K nodes/month) give you the full framework, Studio v2 locally, and LangSmith's free observability tier. Managed cloud requires Plus or Enterprise.
• LangGraph and Temporal solve different layers. LangGraph handles agent reasoning and control flow; Temporal handles durable macro-level orchestration. They are complementary in production stacks, not direct substitutes.
• The naming is confusing but stabilizing. "LangGraph Platform" and "LangSmith Deployment" refer to the same managed product post-October 2025 rebrand. The open-source framework remains "LangGraph."