Field guide
A field guide to six tools that get talked about as if they were the same kind of thing. LangGraph, LangChain, and Deep Agents are three floors of one LangChain stack. LangSmith is the camera that watches that stack. OpenClaw and Hermes are assistants you message, on a computer you control. Read one analogy, play a behavior, then leave with a starting point that fits the job.
The six names
LangGraph, LangChain, Deep Agents, and LangSmith share the LangChain mark. OpenClaw and Hermes are separate projects. Site opens the official page.
Orchestration engine
The lowest layer. You draw the rooms, the doors, and the clipboard. The model only decides where you explicitly let it.
A building with a floor plan
Each room is a step. Doors are rules for what happens next, including doors that loop back. A clipboard (the state) travels with the visitor. If the lights go out, the clipboard is still there in the morning, so work can resume in the same room.
Behaviors
Before the product names: what is the thing actually doing? Play a turn and watch the desk. The tool named on the card is the usual home for that behavior, not a law.
Usually built with LangChain create_agent
The model picks a tool, reads the result, and decides whether to pick another or stop.
The stack
LangGraph runs the work. LangChain supplies parts and a thin agent loop. Deep Agents is that loop with a workshop already installed. They stack. They do not compete.
Runtime
The lowest layer. You draw the rooms, the doors, and the clipboard. The model only decides where you explicitly let it.
Control
Highest
Defaults
Almost none. You design the topology.
You maintain
Nodes, edges, state shape, and where a human may interrupt.
Each room is a step. Doors are rules for what happens next, including doors that loop back. A clipboard (the state) travels with the visitor. If the lights go out, the clipboard is still there in the morning, so work can resume in the same room.
Nodes and edges
A node does work: plain code, one model call, a tool, or a whole agent. An edge says what runs next. Some edges are conditional.
Cycles on purpose
Production agents are rarely straight lines. They retry a failed tool, ask for a missing fact, or revise an answer after a check. Graphs allow those loops.
Explicit state
Everyone reads and writes one shared state object. Reducers decide how updates combine, so you are not hoping the chat transcript remembers the right thing.
Checkpoints
The runtime can save state after steps. A crash, a deploy, or a pause does not throw away the work. It resumes from the last good room.
Human in the loop
A step can interrupt: show a person the proposed action, let them edit it, then continue. This is a first-class pause, not a hack.
Deterministic plus agentic
Put code where you need the same result every time, and a model only where judgment is useful. The floor plan makes that split visible.
Fits
Skip it when
Open source (MIT) · Python and JavaScript
Framework
The parts catalog: models, tools, prompts, retrievers — plus a minimal loop that lets a model call tools until it is done.
Control
High, on a smaller surface
Defaults
Few. The agent loop is deliberately thin.
You maintain
Prompts, tools, and how much context the model sees.
Pipes, switches, and connectors that fit together. You can build a straight assembly line (retrieve, then answer) or a small workbench where the model picks up a tool, looks at the result, and picks up another. You are not handed a finished workshop.
Integrations
One interface for many chat models, tools, retrievers, and vector stores. Swapping a model should not mean rewriting the app.
Pipelines
LCEL (LangChain Expression Language) composes steps as a line: prompt, model, parser. Good when every request should take the same path.
A minimal agent
create_agent is a tool loop with very little built-in opinion. The model decides the next tool. You decide the tools and the instructions.
Sits on the runtime
That agent loop is executed by LangGraph. You can ignore the graph until you need branches, pauses, or durable state.
Middleware
Cross-cutting behavior (guardrails, extra context, human approval) can wrap the loop without redrawing every step.
Not an observability tool
LangChain produces the calls. It does not, by itself, give you a place to replay them, score them, or watch cost.
Fits
Skip it when
Open source (MIT) · Python and JavaScript
Harness
A ready workshop for long, messy tasks: planning, a filing cabinet, specialists in other rooms, and manuals opened only when needed.
Control
Medium. Strong defaults, all replaceable.
Defaults
High. This is the opinionated layer.
You maintain
The goal, the tools that are specific to you, and which defaults to keep.
You walk in and the bench is already set. There is a planning board, a filing cabinet so huge notes do not have to sit in the model's head, a way to send a specialist into another room, and a shelf of skill manuals. You can rearrange the shop. You do not start from an empty room.
Opinionated, defined
Opinionated means the tool already chose how planning, files, and delegation work. You can override those choices. You do not invent them on day one.
Planning
A todo-style tool lets the agent break a goal into steps, mark progress, and change the plan when new facts show up.
A filesystem for context
Large tool results and working notes can live in files. The model reads what it needs instead of dragging the entire history into every call.
Subagents
A task can be handed to another agent with its own context window. The main thread stays short. The specialist goes deep.
Skills
A skill is a folder of instructions the agent loads only when the task matches. The name is visible up front. The long manual stays closed until it is useful.
Still a graph underneath
create_deep_agent returns a LangGraph graph, so streaming, checkpoints, and human approval are available. When the defaults fight you, step down to LangChain or LangGraph.
Fits
Skip it when
Open source (MIT) · Python and JavaScript
Platform
The cameras and the lab notebook. It does not decide the next step. It shows what already happened, and how good it was.
Control
None over the agent loop
Defaults
A hosted workspace, with a free solo tier
You maintain
What you trace, which examples count as good, and who can see production data.
The workshop can run in the dark. LangSmith turns the lights on: every model call, tool, and branch, with the prompt, the answer, the tokens, and the cost. The notebook is where you keep exam questions and score new versions before they reach people.
Traces
A trace is one full turn: nested model calls, tool calls, and errors. You can open the exact prompt that produced a bad sentence.
Evaluation
Save real inputs as a dataset. Score outputs with code, with a person, or with a model acting as a judge. Rerun when something changes.
Prompts as assets
A playground and a prompt hub let people iterate on wording without a redeploy, and keep a history of versions.
Deployment
The managed agent host (formerly called LangGraph Platform) lives here too: run long-lived graphs without standing up all the infrastructure yourself.
Not only for LangChain
SDKs can trace other stacks. The smoothest path is still LangChain and LangGraph, where tracing can be an environment variable.
Commercial, not the library
The frameworks are free. LangSmith is a product: a free developer allowance, then seats and usage. Enterprise plans add self-hosting.
Fits
Skip it when
Commercial platform (free tier + paid) · Any app that can send traces
A different building
OpenClaw and Hermes run on a computer you control. They are products with memory and skills. They are not interchangeable with LangGraph, and LangGraph will not answer a chat app by itself.
Local assistant
An assistant that lives on a computer you control and answers in the chats you already use. You configure it more than you code it.
One front desk (the Gateway) takes messages from WhatsApp, Slack, Telegram, and the rest. The receptionist can use the computer — files, terminal, browser — and keeps notes in the office, not in a vendor's cloud. The brain (the model) is someone you hire and can replace.
It is not a model
OpenClaw routes, remembers, and uses tools. Claude, GPT, an open model, or a local model does the reasoning. You can swap that brain.
Gateway-first
One long-running process is the control plane for sessions, tools, events, and channel connections. Chat apps are doors into that process.
Skills as documents
A skill is a SKILL.md file: when to use it, and how. There is a public registry (ClawHub) and skills that live only in your workspace.
Local memory
Preferences, notes, and history stay on the machine as files and a local database. You can open them and edit them.
Hands on the computer
Shell, files, and a browser are normal tools, with sandbox options. That power is also the main security question: decide what it may touch.
A product, not a library
You install a gateway and message it. Tracing into a lab notebook is optional, through plugins or OpenTelemetry — not built into the framework the way LangChain tracing is.
Open source (MIT) · TypeScript (Node.js)
Local assistant
An assistant built to get better at work you repeat: it files facts, writes a procedure after a hard task, and edits that procedure next time.
The first time a tricky job is solved, the apprentice writes a recipe card: steps, pitfalls, how to check success. Next time, they follow the card and correct it if a step was wrong. Facts about you live on a small index card, separate from the recipes. Old conversations can be searched.
Learning loop
After a complex task, the agent can distill a skill. When it uses that skill again, it can patch the file. Learning is editing text, not retraining the model.
Facts versus procedures
A short memory holds stable facts and preferences. Skills hold multi-step know-how and load only when relevant. Mixing them makes both worse.
Session search
Past conversations are stored locally and can be searched, so 'like last Thursday' is a retrieval, not a hope.
Agent-first
The center is the agent loop. Chat channels and a gateway are ways to reach it. That is the mirror image of OpenClaw, where the gateway is the center.
Where code runs
Commands can run locally or through other backends (containers, another machine). The agent is not tied to one laptop session.
Model-agnostic
Point it at a hosted model or a local endpoint. The harness — memory, skills, tools — stays. The brain can change.
Open source (MIT) · Python
| OpenClaw | Hermes | |
|---|---|---|
| Center of the design | A gateway that many chats connect to | An agent loop that learns procedures |
| Memory you can open | Local notes and session history | Curated facts, skill files, session search |
| How it improves | You add or edit skills | It can write and patch skills after real tasks |
| Language | TypeScript | Python |
| What it is not | A model, or a workflow library | A multi-channel front desk first |
How they fit
Read the stack from the floor up. The assistants sit in another building on purpose.
HarnessDeep AgentsTop floor. Workshop already furnished.FrameworkLangChainMiddle. Parts, and a thin tool loop.RuntimeLangGraphFoundation. Runs steps, saves the clipboard, resumes.Three layers, one stack
Deep Agents is a harness on top of LangChain's agent framework, which runs on the LangGraph runtime. You can enter at any floor. Moving down is how you gain control. Moving up is how you stop rebuilding the same workshop.
LangSmith stands beside the stack
It is not a fourth layer of behavior. The agent can run without it. You just cannot see the run clearly. Traces, scores, and hosted deployment live here.
Assistants are a different building
OpenClaw and Hermes are ready-to-run local assistants. They are not drop-in replacements for LangGraph, and LangGraph is not a chat product. A team can use an assistant for daily work and a graph for a product workflow.
Most 'agents' should not be agents
If the steps never change, build a chain. An agent is for when the next action depends on what just happened and you are willing to let a model choose.
A short decision
Two questions. The answer names a starting point and the reason you would leave it.
Watching the work
An agent that only shows the final chat message is a closed box. Observability is a separate decision from which agent you build.
A trace records each model call and tool call, not only the last sentence. A wrong turn becomes obvious.
Keep a set of real examples. When the prompt or the model changes, run them again.
Long agents spend tokens in loops. Tokens and latency should be visible before the bill is.
Glossary
If a slide uses one of these without a meaning, it is not a strategy yet.
Descriptions follow the public split used by the LangChain ecosystem in 2026 — runtime, framework, harness, platform — and the OpenClaw and Hermes projects as documented then. Products move. Check current docs before you commit a stack.