LangGraph development for production agents
Stateful, checkpointed agent graphs with human approvals, multi-agent routing and full tracing.

How we use LangGraph
LangGraph models an agent as an explicit graph of steps over shared state. That makes agents debuggable, resumable and testable, which is why we use it for most custom agent work. We design the graph, the state, the tools and the checkpoints, then wire in tracing and evaluation.
What we build with it
- Customer support and operations agents that act in your systems
- Research and analysis agents with planning and self-checks
- Supervisor and swarm multi-agent teams
- Agents embedded in your product behind your API
LangGraph, running on our machines
Real screenshots and the exact code behind them, from a run on our own machines.

"""Support agent from the vithupro.in hero: supervisor -> specialist agents -> human approval before any refund.
Runs offline (stub logic instead of LLM calls) so the graph, checkpointing and interrupt can be verified and drawn."""
from typing import Literal, TypedDict
from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import END, START, StateGraph
from langgraph.types import Command, interrupt
class State(TypedDict, total=False):
request: str
order: dict
policy: str
decision: str
reply: str
def supervisor(state: State) -> Command[Literal["research", "retrieval"]]:
# In production this is an LLM routing call with structured output.
return Command(goto="research" if "order" not in state else "retrieval")
def research(state: State) -> dict:
# Tool call over MCP: get_order(order_id) -> a narrow, typed, read-only tool.
return {"order": {"id": "4821", "status": "delivered", "damaged": True, "amount": 2499}}
def retrieval(state: State) -> dict:
# GraphRAG lookup over the policy knowledge graph, with citations.
return {"policy": "Damaged on arrival: full refund within 7 days [policy.pdf p.3]"}
def action(state: State) -> dict:
# Irreversible step: pause the graph and wait for a person.
answer = interrupt({"proposed": f"refund_order({state['order']['id']})", "because": state["policy"]})
return {"decision": answer}
def respond(state: State) -> dict:
ok = state.get("decision") == "approve"
return {"reply": "Refund approved and issued." if ok else "A teammate will review your request."}
builder = StateGraph(State)
builder.add_node("supervisor", supervisor)
builder.add_node("research", research)
builder.add_node("retrieval", retrieval)
builder.add_node("action", action)
builder.add_node("respond", respond)
builder.add_edge(START, "supervisor")
builder.add_edge("research", "supervisor")
builder.add_edge("retrieval", "action")
builder.add_edge("action", "respond")
builder.add_edge("respond", END)
graph = builder.compile(checkpointer=MemorySaver()) # Postgres saver in production
if __name__ == "__main__":
cfg = {"configurable": {"thread_id": "ticket-4821"}}
first = graph.invoke({"request": "Order #4821 arrived damaged. I want my money back."}, cfg)
print("paused for approval:", first["__interrupt__"][0].value)
final = graph.invoke(Command(resume="approve"), cfg) # a human clicks Approve
print("reply:", final["reply"])
print(graph.get_graph().draw_mermaid())paused for approval: {'proposed': 'refund_order(4821)', 'because': 'Damaged on arrival: full refund within 7 days [policy.pdf p.3]'}
reply: Refund approved and issued.Patterns we rely on
Explicit state and conditional edges
Typed state and routing functions instead of a free-running loop, so every path is visible and testable.
Checkpointing
Postgres checkpointers persist each step, so a conversation or task resumes after a crash, and you can replay or branch from any step.
Human-in-the-loop interrupts
The graph pauses before sensitive actions and waits for approval or edits, then continues from the same state.
Multi-agent topologies
Supervisor, hierarchical and swarm patterns with subgraphs, so specialist agents stay small and focused.
Our production checklist
What we put in place before a LangGraph system goes live.
- Typed state schema and tool contracts
- Step and token limits per run
- Checkpointer on Postgres with retention policy
- Tracing in LangSmith or Langfuse
- Scenario eval suite run before each release
- Streaming responses to the UI
Questions
Do you deploy on LangGraph Platform?
We can. We also self-host LangGraph behind FastAPI on your cloud when you prefer to keep everything in your own accounts.
Can LangGraph use any model?
Yes. We regularly mix providers in one graph, for example a cheaper model for routing and a stronger one for reasoning steps.
Often used together with:
Need LangGraph engineers?
Tell us what it needs to do. We reply within one business day with questions, a rough plan and the next step.
- Free 30-minute architecture call
- NDA before you share details
- You own all code and IP
- Reply within one business day