Agent OS — durable agents in your TypeScript backend. Start with Meridian →
HazelJS LogoHazelJS

Comparison

HazelJS vs LangGraph

LangGraph is a strong agent graph runtime. HazelJS Agent OS covers durable AgentRun HITL, DNA packaging, Skillgate, local apply, and your API layer without a separate web framework.

Updated August 7, 2026

HazelJS vs LangGraph

TL;DR

  • LangGraph focuses on agent workflows and stateful graphs (often with LangChain).
  • HazelJS Agent OS — durable AgentRun stores, crash-safe HITL, DNA, Skillgate, local apply — and HTTP in one TypeScript backend.
  • Use LangGraph when you are deep in the LangChain ecosystem and only need the graph runtime.
  • Use HazelJS when agents must live beside REST, auth, and production ops — clone Meridian.

Who this is for

Teams comparing:

  • LangGraph checkpointed agents vs HazelJS AgentGraph / Supervisor patterns
  • Durable execution for approvals, orders, or multi-step AI jobs
  • Whether to keep a separate HTTP framework around LangGraph

Prefer LangGraph if your org standardized on LangChain + LangGraph and the API edge is already solved.

Scope difference

LayerLangGraphHazelJS
Agent DAGs / state machinesCore product@hazeljs/agent — AgentGraph, SupervisorAgent, @Delegate
Durable business workflowsCheckpointing patterns@hazeljs/flow — WAIT/resume, idempotency, Prisma storage
HTTP / REST for flowsYou wire Express/Nest/etc.Controllers + @hazeljs/flow-runtime
RAGVia LangChain@hazeljs/rag (GraphRAG, memory, loaders)
Agent OS (loops, policies, CI)DIY / LangSmithAgent OS
Durable AgentRun + leasesCheckpoint DIYAgent OS Gamma
OpenAPI → agent toolsCustom tool wrappersSkillgate

Side-by-side

AspectLangGraphHazelJS
FocusAgent workflows, state machinesAI-native backend + Agent OS
Agent orchestrationCore strengthAgentGraph, SupervisorAgent, @Delegate
Durable agent runsCheckpointing patternsSQL/file AgentRun, HITL suspend, worker leases
REST as agent skillsManual toolsSkillgate (fromOpenApi / fromModule)
Durable business workflowsOutside core@hazeljs/flow WAIT/resume + optional Prisma
HTTP/RESTYou wire itNative controllers; flow REST via flow-runtime
RAGVia LangChainNative RAG package
Backend concernsOutside LangGraphAuth, gateway, resilience, serverless in-ecosystem

Code sketches

HazelJS agent with human-in-the-loop tool:

import { Agent, Tool } from '@hazeljs/agent';

@Agent({
  name: 'ops-agent',
  systemPrompt: 'Triage incidents; escalate refunds.',
  enableMemory: true,
})
export class OpsAgent {
  @Tool({
    description: 'Issue a refund',
    requiresApproval: true,
    parameters: [
      { name: 'orderId', type: 'string', required: true },
      { name: 'amount', type: 'number', required: true },
    ],
  })
  async refund(input: { orderId: string; amount: number }) {
    return { ok: true, ...input };
  }
}

Durable workflow direction (@hazeljs/flow): model WAIT/resume steps for approvals and long-running jobs in the same monorepo as your HTTP modules — see Flow package docs.

Decision guide

NeedPrefer
LangChain-centric agent graphs onlyLangGraph
Agent graphs + REST + auth in one TS appHazelJS
Human approvals + durable order/fulfillment flowsHazelJS @hazeljs/flow (+ agents)
Already Nest + LangGraphEvaluate NestJS + LangChain vs HazelJS

When LangGraph is better

  • Team expertise and docs are LangGraph-first
  • You do not want another web framework
  • You rely on LangGraph-specific checkpoint stores already in production

HazelJS is better when the product is an AI backend: agents, RAG, and APIs sharing modules, config, and observability.

Related

Next steps

  1. Clone Meridian
  2. Agent OS guide
  3. Skillgate
  4. Agent package
  5. GitHub

FAQ

Does HazelJS have something like LangGraph?
Yes — multi-agent routing via @Delegate / callAgent, plus durable AgentRun with crash-safe HITL. Separately, @hazeljs/flow handles WAIT/resume business workflows (not the same as AgentRun HITL).
Can LangGraph and HazelJS coexist?
You can invoke LangGraph from a HazelJS service, but you will still maintain two runtimes. Most Agent OS adopters consolidate on @hazeljs/agent.
What about checkpointing?
Agent OS durable runs use file or SQL stores with durableSuspend / approveAndResume. Evaluate against your LangGraph checkpoint store requirements.
When is LangGraph clearly better?
When your organization is standardized on LangChain/LangGraph and you only need the graph runtime behind an existing API edge.

Docs & next steps

Related comparisons

  • HazelJS vs LangChain

    LangChain composes LLM pipelines. HazelJS Agent OS runs those agents inside a production TypeScript backend — DNA, crash-safe HITL, Skillgate, local apply, same DI as your APIs.

  • NestJS + LangChain vs HazelJS

    Nest + LangChain works but creates two paradigms. HazelJS Agent OS unifies durable agents, DNA, Skillgate, and local apply in the same DI app as your APIs.

  • HazelJS vs Vercel AI SDK

    Vercel AI SDK optimizes streaming UX. HazelJS Agent OS is the backend for durable agents, DNA, Skillgate, and TypeScript APIs — they can complement each other.

← All comparisons