Namzu vs LangChain. kernel vs orchestration layer.
The two tools sit at different layers of the agent stack. The short version: Namzu is an agent kernel — runtime, scheduling, sandboxing. LangChain is a python/js orchestration framework. They compose more often than they compete.
Namzu
Namzu is an open-source TypeScript agent kernel and SDK. It owns the runtime layer: process lifecycle, scheduling, memory, IPC, sandboxing, and checkpoint/resume. It does not prescribe how an agent thinks, only how it runs.
LangChain
LangChain is the most widely adopted agent orchestration framework. It models agents as chains of calls — prompt templates, tool bindings, retrievers, memory wrappers, and (via LangGraph) explicit state graphs. It is opinionated about composition and integrations, and runtime-agnostic.
Choose Namzu if…
- →You need OS-level process isolation between agents (multi-tenant, untrusted code, long-running tools).
- →You want to pause, snapshot, and resume an agent across machines.
- →You are running TypeScript and want a thin, vendor-neutral runtime — not a Python-first framework.
- →You need to swap LLM providers without touching agent code.
Choose LangChain if…
- →You want a large catalogue of pre-built integrations (vector stores, retrievers, document loaders).
- →Your team already lives in Python and you need an opinionated framework for chains and graphs.
- →You want LangSmith tracing and the LangChain ecosystem out of the box.
These are different layers — they compose. An agent expressed as a LangGraph state machine can run inside a Namzu process, gaining sandboxing, scheduling, and checkpointing without giving up LangChain integrations. Migration tends to be additive: keep your composition layer, drop Namzu in underneath when you outgrow ad-hoc process management.
Try the kernel underneath your stack.
Namzu installs from npm and runs on Node.js today. Pair it with whichever agent layer you already use.