LangGraph / LangChain / LangSmith

1. Introduction

1.1. Positioning of the Three

LangChain's product line consists of three parts, and understanding how they divide up the work is a prerequisite for understanding their Harness positioning:

In one sentence, the relationship among the three is: LangChain provides the bricks, LangGraph provides the structure, and LangSmith provides the dashboard.

LangGraph's birth had a clear engineering motivation. LangChain's early Agent Executor was a black box: receive a query → call the LLM → parse the tool name → execute the tool → feed back the observation → repeat until the model gives a final answer. This loop could not be inspected mid-run, could not persist state across calls, could not insert a human in the middle of a long task, and could not branch. The subsequently introduced LCEL (LangChain Expression Language) simplified component wiring, but it was by design a directed acyclic graph and could not loop.

LangGraph was built precisely to fill in these three things: explicit looping, persistable state, and human-in-the-loop.

1.2. Basic Facts Card

1.3. Development Timeline

LangChain officially positions 1.0 as a "stability milestone rather than feature stacking", quoting: "This is the first stable major release in the durable agent framework space, a major milestone for production-ready AI systems." It also states that after 1.0 it will follow a strict no-breaking-changes policy until the hypothetical 2.0.

1.4. Position in the AI Harness System

According to the parameter card boundary table, LangGraph is a typical representative of the Agent Framework — primarily covering L2/L3, i.e. a subset of the Harness. But LangGraph's actual coverage is broader than a typical framework: it reaches L4 through the Checkpointer and Store, and L5 through LangSmith.

Key assessment:

• The LangGraph library itself = part of L2 + L3 + L4;
• LangSmith = L5 (+ some L6 RBAC / SSO, Enterprise only);
• Together, the two form the combination closest to a complete Harness in today's open-source ecosystem, but L6 governance and cost guardrails remain largely absent.

2. Glossary

3. Feature Description

3.1. Graph Computing Model and Pregel-style Execution

LangGraph's design was led by Nuno Campos, the first employee of LangChain, and explicitly drew on two systems:

• Pregel: Google's Bulk Synchronous Parallel framework for processing web graphs;
• Apache Beam: a data processing model unifying batch and stream processing.

In execution semantics this translates to: agent control flow = a directed graph with explicit looping + a shared state object + a Pregel-style execution loop (the writes of all nodes in one superstep become uniformly visible at the start of the next).

The direct product of this model is four things that other frameworks struggle to do:

1. Deterministic branching (conditional edges are decided by state and are assertable);
2. Looping (something LCEL could not do);
3. Checkpointing (every superstep is naturally a save point);
4. Resuming from a checkpoint after a crash.

3.2 State / Node / Edge / Graph

Only four core exported concepts (state / node / edge / compiler) plus one persistence layer (checkpointers + stores) support the vast majority of production behavior — this is one of the most praised aspects of LangGraph's design.

3.3 Checkpointer and Persistence

The three capabilities the Checkpointer brings:

1. Durable Execution: recovers from the most recent checkpoint after a crash without rerunning the whole task;
2. Multi-Thread support: the same graph can concurrently serve multiple sessions;
3. Time Travel: go back to any historical checkpoint and rerun.

3.4 Human-in-the-loop and Time Travel

• Interrupt: you can pause at any node, wait for a human to approve or edit the state, then resume;
• Use cases: before irreversible or high-consequence actions (external payments, production changes, outgoing email);
• Time Travel: based on checkpoint rollback, it is the key capability for "debugging the agent" rather than "debugging the prompt".

These two together are the strongest evidence for LangGraph on the "predictability" side.

3.5 The LangSmith Trio

Key design orientation: LangSmith is open — even if an agent is not built with LangChain / LangGraph, it can still use LangSmith.

3.6 Known Engineering Costs

Public evaluations candidly pointed out LangGraph's three costs:

1. Heavy engineering: developers must design the state schema, node functions, edges, checkpointer backend, and HITL interrupt points themselves; independent developers are often unable to bear the maintenance cost.
2. No business workbench: LangGraph provides an agent runtime, not a task board, chat UI, CRM, or email inbox — all the "front doors" facing real users must be built yourself.
3. No cost protection: a misconfigured loop can self-prompt for hundreds of iterations before it is noticed; cost guardrails must be built by you.

4. Platform Architecture

图 4-1｜LangGraph 三件套分层架构：从 LangSmith 平台到执行面

数据来源：基于本文分析绘制的示意图。

4.1 Layered Architecture of the Three

┌──────────────────────────────────────────────────────────┐
│ LangSmith（商业平台）                                      │
│  Observability（tracing + 聚合指标 + Insights Agent）      │
│  Evaluation（生产数据 + 离线数据集打分）                    │
│  Deployment（原 LangGraph Platform，长任务基础设施）         │
│  Agent Builder（无代码，私有预览）                          │
│  Enterprise：自托管 / 混合 / SSO / RBAC-ABAC / SLA          │
└──────────────────────────────────────────────────────────┘
                          │（可独立使用，不强绑定）
┌──────────────────────────────────────────────────────────┐
│ LangGraph（MIT）                                          │
│  Graph Compiler（state + node + edge → 可执行图）           │
│  ├─ Pregel 式执行循环（superstep 批量同步）                 │
│  ├─ Checkpointer（InMemorySaver / SqliteSaver / 生产后端）  │
│  ├─ Store（跨会话记忆）                                    │
│  ├─ Interrupt（HITL 暂停 / 恢复）                          │
│  └─ Streaming（token 级）+ Moderation hooks                │
└──────────────────────────────────────────────────────────┘
                          │
┌──────────────────────────────────────────────────────────┐
│ LangChain（开源构建库，1.0 由 LangGraph 运行时驱动）         │
│  模型集成 · 检索器 · 工具 · 记忆后端                        │
└──────────────────────────────────────────────────────────┘
                          │
┌──────────────────────────────────────────────────────────┐
│ 执行面（需自建 / 外挂）                                     │
│  沙箱（如 Daytona）· 向量库 · 业务工作台 · 成本护栏           │
└──────────────────────────────────────────────────────────┘

4.2 A Graph Run with an Interrupt

1. Compile the graph, specifying the checkpointer and thread id;
2. Enter superstep N: execute this round's ready nodes in parallel, writing to the staging area;
3. Superstep ends: the checkpointer persists a checkpoint;
4. If the next node is marked as an interrupt: execution pauses, and the state is frozen at the checkpoint;
5. A human approves or edits the state;
6. Resume execution: continue from the checkpoint and enter superstep N+1;
7. When no nodes are ready → the graph ends;
8. If it crashes midway: resume from the most recent checkpoint by thread id, without rerunning.

5. Harness Design

5.1. Six-Layer Capability Overview

5.2. L1 Context Engineering Layer

LangGraph's contribution at L1 is to make context an explicit data structure:

• State is an object with a schema; every piece of content that enters context must first be written into state;
• This turns context trimming, priority sorting, and injection policy into programmable code rather than prompt mysticism;
• Store provides cross-session memory, used for "rich, personalized interactions".

Shortcomings:

• No built-in context compaction (Compaction);
• No built-in retrieval ranking primitives (RAG relies on LangChain retrievers or is self-built);
• No progressive disclosure mechanism (compared with Claude Agent SDK's Skills).

5.3. L2 Tools and Execution Layer

• Tool form: tools are nodes; they can also be invoked as capabilities inside a node;
• Integration maturity: the integration of models, retrievers, tools, and memory backends is the most mature of the three;
• Sandbox: not built in. In public cases, LangGraph-family products (such as Open SWE) use external sandboxes (Daytona) for execution isolation.

L2 is rated "strong but incomplete" — tool orchestration is first-rate, but execution isolation must be attached externally.

5.4. L3 Orchestration and Control Layer

This is LangGraph's raison d'être, and the strongest L3 implementation among the seven platforms in this group.

Flexibility ↔ predictability tension: LangGraph sits at the predictability endpoint of this axis:

• What it gains: execution order that is assertable, regressable, replayable, and time-travelable;
• What it pays: paths must be enumerated in advance, and designing control flow for open-ended tasks is extremely costly; the graph becomes a new source of complexity.

At the other end of the same axis is Claude Agent SDK's implicit loop; in the middle is OpenAI Agents SDK's handoff. There is no better or worse among the three — only differences in how well each matches a given task shape.

5.5. L4 Memory and State Layer

This L4 is tied with ADK as the strongest in this group. The difference: ADK additionally distinguishes three kinds of objects — "session state / long-term memory / artifacts" — and version-manages artifacts; LangGraph unifies all state in the State + Checkpoint + Store model, which is lower cognitive overhead but coarser in semantics.

5.6. L5 Evaluation and Observability Layer

Strict breakdown:

Important qualification: these capabilities are not within the MIT open-source scope. The Developer tier is $0 / seat but only 5,000 base traces / month; Plus is $39 / seat; RBAC-ABAC and self-hosting are Enterprise only.

Therefore this platform's L5 is assessed as "strong (requires LangSmith)" — if a team uses only open-source LangGraph without connecting LangSmith, L5 is actually missing, even weaker than Claude Agent SDK's Hooks export approach (which at least has an export point).

5.7. L6 Governance and Security Layer

The cost ↔ depth tension was called out on this platform by public evaluations: "It does not protect your cost. A misconfigured loop in a stateful graph can self-prompt for hundreds of iterations before you notice. Cost guardrails have to be built by you."

This sentence should be item one of any LangGraph pre-launch checklist.

5.8. Concrete Manifestations of the Three Inherent Tensions

6. Real-world Cases

Case 1: Open SWE (LangChain's official open-source asynchronous coding agent)

The architecture divides work among specialized components: Manager (user interaction) → Planner (codebase research and execution strategy) → Programmer-Reviewer pair (implementation and verification). Key innovations:

• Human-in-the-loop plan review (the plan is confirmed by a human before implementation);
• "double texting" (real-time feedback, appending instructions mid-run);
• Deep GitHub integration (tracking issues);
• Runs in a Daytona isolated sandbox to ensure security;
• A strict plan-review-implement loop, completing planning and QA before a PR is produced.

Case 2: Open Deep Research (open-sourced 2025-07-16)

A LangGraph-implemented three-stage pipeline: scope (defining scope) → research (retrieval research) → write (writing), supporting pluggable models, search tools, and MCP servers. This is a typical example of "freezing a research methodology into a graph".

Case 3: Production-grade customer validation (v1.0 announcement)

In its 1.0 release announcement, LangChain listed that Uber, LinkedIn, and Klarna are already in production use; Replit, Clay, Harvey, Rippling, Cloudflare, Workday, Cisco, and others are its customers. Officially, 1.0 is characterized as "locking in the patterns already validated at Uber, LinkedIn, and Klarna, rather than cramming in new features".

Case 4: NVIDIA trains agents with the LangGraph Platform CLI (third-party report)

NVIDIA proposes training CLI-task agents with synthetic data generation + reinforcement learning with verifiable rewards (RLVR), so that large reasoning models can safely learn to operate the LangGraph CLI without real logs; Group Relative Policy Optimization reduces training VRAM usage by up to about 80%. The agent runs in a human-in-the-loop framework, using a multi-layer security architecture (runtime checks + execution isolation) to prevent injection attacks. This case comes from a third-party aggregator, not an official release, and all its data is marked [To be verified].

Parts for which no public quantitative data was found: none of the above cases discloses verifiable metrics such as cost-reduction percentages, task-success-rate improvements, or labor-substitution rates. No official disclosure of Uber / LinkedIn / Klarna's specific deployment scale and results was found either; this is truthfully noted here and not filled in.

7. Summary

7.1. Strengths

1. Strongest L3: explicit graph + explicit looping + conditional edges + checkpoints + interrupt + time travel, with control flow fully engineered.
2. Durable Execution: crash recovery and long-pause resume is the most reliable implementation in this group.
3. Complete L4: the Checkpointer + Thread + Store + Time Travel four-piece set.
4. MIT license, no runtime lock-in: the library is free and can be arbitrarily self-hosted; only LangSmith's tracing, evaluation, and hosted deployment are paid.
5. Mature ecosystem: the most complete integration of models, retrievers, tools, and memory backends; 90M monthly downloads.
6. Well-proven commercially: 35% of the Fortune 500, 2025 ARR doubled, $1.25B valuation, LangSmith trace volume up 12x year-over-year.
7. No breaking changes after 1.0: an explicit promise of no breaking changes until 2.0, suitable for production lock-in.

7.2. Weaknesses

1. Heavy engineering: state schema, nodes, edges, checkpointer, and interrupts must all be designed and maintained by yourself.
2. No business workbench: all user-facing front doors — task boards, chat UIs, CRM, email, etc. — must be built from scratch.
3. No cost protection: a misconfigured loop can self-prompt hundreds of times, and cost guardrails must be self-built — this is the most serious production risk.
4. L5 depends on commercial components: without connecting LangSmith, evaluation and observability are largely absent.
5. No sandbox: execution isolation requires external attachment (e.g. Daytona).
6. Weak L6: beyond Moderation hooks, there is no approval queue, no spend guardrails, and RBAC is Enterprise only.
7. Open-ended tasks are costly: paths must be enumerated in advance, which is inherently mismatched with exploratory tasks.

7.3. Applicability Boundaries

7.4. Selection Recommendations

• If a team's core need is control, recoverability, and replayability, LangGraph is the first choice in this group, forming a clear contrast with Claude Agent SDK's implicit loop: the former trades for predictability, the latter for flexibility.
• If you already use the LangChain ecosystem, LangGraph's migration and integration cost is the lowest.
• If you just want to build a simple three-role pipeline, CrewAI-style role frameworks need less code; if you don't want to think about graphs at all, choose an Agent Platform instead (see 05-dify.md).
• Three things that must be self-built before launch: a hard cap on iteration count, per-thread budget counting and alerts, and an execution sandbox.

Information Gap Statement

1. GitHub star count sources conflict: one third-party count is 39,176 stars (2026-08); another states langchain + langgraph total roughly 118,000 stars; they could not be reconciled, marked [To be verified].
2. Latest version: a third-party timeline says LangGraph 1.2 was released on 2026-05-12; it was not cross-checked with the official release page, marked [To be verified].
3. LangSmith pricing details: the Developer / Plus / Enterprise tier prices come from a third-party compilation, and the metered unit prices ($1.50 / Compute Unit, $1.00 / Storage Unit) are third-party sources, not cross-checked item by item against the official pricing page, marked [To be verified].
4. Specific model unit pricing: not within the scope of this search, marked [To be verified].
5. The NVIDIA case: from a third-party aggregator, with no official NVIDIA or LangChain release found; all data is marked [To be verified].
6. Enterprise deployment quantitative data: no official quantitative disclosure of the deployment scale, cost/benefit, or success rates of customers such as Uber / LinkedIn / Klarna was found; nothing was filled in.
7. Sandbox solution details: no dedicated search was done on the integration methods and version compatibility of external sandboxes such as Daytona.
8. Detail of the relationship between LangChain 1.0 and the LangGraph runtime: officially, langchain 1.0 is said to be "driven by the langgraph runtime", but the specific implementation mechanism was not verified at the source-code level.

8. References

1. LangChain raises $125M to build the platform for agent engineering — LangChain Blog, 2025-10. http://blog.langchain.com/series-b
2. LangGraph — AI Wiki (includes the full version timeline and the Pregel / Apache Beam design sources). https://aiwiki.ai/wiki/langgraph
3. LangGraph — Beri.net (MIT license, pricing, customers, GitHub scale). https://beri.net/tools/langgraph
4. LangGraph Review — Sistava (a candid review of engineering costs and applicability boundaries). https://sistava.com/en/ai-agent-platform-reviews/dev-frameworks/langgraph
5. LangGraph — agentjido product page (Open SWE, NVIDIA, Gemini 3 integration, and other updates). http://agentjido.ai/product/?product_id=3913
6. LangChain official website and pricing page. https://www.langchain.com/; https://www.langchain.com/pricing
7. R05-Data Science Group search report (Open Deep Research 2025-07-16 three-stage pipeline) — internal search report for this project.
8. R03-Hardware R&D Group search report (application of LangGraph multi-agent control flow in the chip design pipeline) — internal search report for this project.
9. R01-Overview search report (the three-layer distinction of Framework / Harness / Agent) — internal search report for this project.
10. Project parameter card v1.0 (six-layer capability model and conceptual boundaries) — internal baseline document for this project.