LangGraph consulting that takes agents into production.
We design, build and harden LangGraph agents: durable state in Postgres, interrupts for human approval, retries that do not duplicate a side effect, and a LangSmith trace on every run. Built by official LangChain Ambassadors and Experts.
From the first graph to a run that survives a restart.
Durable execution
Checkpointers and durability modes
Every step is checkpointed to Postgres under a stable thread id, so a run resumes where it stopped after a crash or a deploy, and a user can leave and come back without losing state. The durability mode is chosen per graph, not left at the default.
Human in the loop
Interrupts and approval gates
The graph pauses before a side effect, a person approves, edits or rejects, and the run resumes on the same thread. Writes before the pause are idempotent, because the node restarts on resume.
Transient failures get a per-node retry policy with a timeout. When retries are exhausted, an error handler routes to a fallback or to a person and records in state what failed and why.
Multi-agent patterns
Supervisor, handoffs, or one agent
A supervisor over domain subagents, handoffs when agents take turns talking to the user, a router when the input categories are clear, and a single agent whenever a few tools are enough.
Streaming
Tokens, updates and progress events
Stream modes for model tokens, state updates and custom progress events from any node, tool or subgraph, so the user watches the agent work instead of a spinner.
Deployment and tracing
Agent Server on LangSmith Deployment
Packaged with a langgraph.json, run locally with the LangGraph CLI, then deployed to LangSmith Deployment in the cloud, in your VPC or self-hosted, with every run traced and evaluated in LangSmith.
What does LangGraph development consulting include?
Soba Labs designs the graph and its state, builds the nodes and tools, adds a Postgres checkpointer, interrupts for approval, retry policies and streaming, deploys it and traces every run in LangSmith. We work in your repository with your team, and you own the code.
When should we use LangGraph instead of create_agent or Deep Agents?
LangChain's create_agent returns a compiled LangGraph graph for the standard loop of model call, tool call, repeat, with middleware for approval, summarization and prompt changes. Deep Agents adds a file system for context, subagents and long-term memory for long, open-ended tasks. Write the LangGraph graph yourself when the topology is more than loop until done: classify before routing, fan out in parallel, run deterministic steps between model calls, or gate something that is not a tool call. All three run on the same runtime, so an agent from create_agent can be one node in a larger graph. See the LangGraph glossary entry for the basics.
How do you make a LangGraph agent durable in production?
With a Postgres checkpointer and a stable thread id per conversation or job, so every step is saved and a run resumes after a restart. We set the durability mode per graph: synchronous writes where a lost step would cost a duplicate side effect, background writes where throughput matters more, and a job that prunes old checkpoints so the table does not grow without limit. The Shen.ai case study shows session checkpointing in Postgres in a patient-facing assistant.
How do you add human approval to a LangGraph agent?
Tool calls get LangChain's human-in-the-loop middleware, which pauses before the tool runs. Anything else, a stage boundary or a threshold breach, gets an interrupt() call in its own node, resumed with a Command on the same thread. Because the node restarts from the top on resume, we keep writes before the interrupt idempotent or move them to the node after it. The reasoning is in LangGraph human-in-the-loop: interrupt vs middleware.
Should we build a multi-agent system?
Usually not at first. A supervisor earns its place when there are several distinct domains, each with its own tools, and the subagents never talk to the user. Handoffs fit when agents take turns in one conversation. A router fits when the input categories are clear. Every extra agent is another prompt to maintain and another evaluation set to keep green, so we add one only when a single prompt can no longer hold its tools and instructions.
Where does a LangGraph agent run in production?
Either inside your own service around the compiled graph, or on LangSmith Deployment's Agent Server, which packages the graph with a persistence database and a task queue and exposes threads, runs and cron jobs over an API. It runs as managed cloud, hybrid with the agents in your VPC, fully self-hosted, or as standalone containers. We choose with your team based on where the data has to stay.
How do you keep a LangGraph agent accurate after launch?
Every run is traced in LangSmith, failures from live traffic become examples in an evaluation dataset, and each prompt, model or graph change is scored against that dataset before it ships. The same loop lets us test an automatic prompt optimizer against a fixed task set before trusting its output, as in our Agent Lightning experiment.
How is a LangGraph engagement priced?
Like every Soba Labs engagement: a fixed price on a defined outcome, agreed before we start. You own the graph, the checkpoints, the evaluators and the code.
We sell a fixed price on a defined outcome, delivered in days. Every system is custom to your process and your data, and you own it and its source. No product to license, no platform to rent, no lock-in.
No advertising or tracking cookies, and our visitor counts are anonymous. The Cal.com booking widget loads only if you allow it. Privacy Policy.
The page itself, anything our host sets to serve and secure it, and the anonymous visitor count. Always on, and none of it stores anything on your device.
The Cal.com booking widget. Left off, a booking link opens the booking page instead of a popup, so you can still book a call.