Namzu is an open-source TypeScript agent kernel and SDK for building AI agents. It owns the runtime layer beneath agent frameworks — process lifecycle, scheduling, memory, IPC, sandboxing, and checkpoint/resume.

What is an agent kernel, and how is it different from an agent framework?

A kernel owns the runtime: how an agent process is created, isolated, scheduled, paused, resumed, and persisted. A framework owns composition: how prompts, tools, and graphs fit together. Namzu is the kernel; agent frameworks sit above it.

What languages does Namzu support?

TypeScript today, via @namzu/sdk on Node.js. The kernel specification is portable by design; Rust, Go, and Python kernels sharing the same spec are on the public roadmap.

How does Namzu compare to LangChain or LangGraph?

LangChain and LangGraph are orchestration layers — they describe what an agent does. Namzu is the layer underneath — it describes how the agent runs. They are complementary, not competitors.

Is Namzu vendor-locked to a specific LLM provider?

No. The kernel exposes a narrow LLMProvider interface; provider integrations live in sibling packages including @namzu/anthropic, @namzu/openai, @namzu/openrouter, @namzu/bedrock, @namzu/ollama, @namzu/lmstudio, and @namzu/http.

Can I self-host Namzu?

Yes. Namzu is a library, not a hosted service. Install @namzu/sdk from npm and run it on your own infrastructure. There is no cloud component, no hosted control plane, and no required telemetry.

What license is Namzu under?

Namzu is released under FSL-1.1-MIT — free to run, fork, extend, and commercialise. The license converts to MIT after two years.

Where do I report bugs or request features?

On GitHub Issues at github.com/cogitave/namzu. Architectural decisions land as ADRs in the same repo before they ship.

New@namzu/sdk v0.6.0·Changelog

An operating system for AI agents.

Namzu is an open-source TypeScript agent kernel and SDK for building AI agents — process-level isolation, scheduling, memory, IPC, and checkpoint/resume in one runtime.

Self-hosted, vendor-neutral, language-agnostic. Community-driven — because the ground autonomous software stands on is too important to belong to any single vendor.

Read the manifesto View on GitHub

shell

$ pnpm add @namzu/sdk @namzu/ollama

Scroll

§01Quick start

Install the kernel. Register a provider. Reason.

01Install

$ pnpm add @namzu/sdk @namzu/ollama

02First conversation

app.ts

import { ProviderRegistry, createUserMessage } from '@namzu/sdk'
import { registerOllama } from '@namzu/ollama'

registerOllama()

const { provider } = ProviderRegistry.create({
  type: 'ollama',
  host: 'http://localhost:11434',
})

const response = await provider.chat({
  model: 'llama3.2',
  messages: [createUserMessage('Summarise Unix philosophy in one line.')],
})

console.log(response.message.content)

03Every vendor implements this

types/provider/interface.ts

interface LLMProvider {
  readonly id: string
  readonly name: string

  chat(params: ChatCompletionParams): Promise<ChatCompletionResponse>

  chatStream(params: ChatCompletionParams): AsyncIterable<StreamChunk>

  listModels?(): Promise<ModelInfo[]>
  healthCheck?(): Promise<boolean>
}

§02Four shapes it fits

Namzu is runtime. What you build on top is yours.

Autonomous coding agents

Claude-Code-style workflows, IDE companions, refactoring bots. Tool gating and budgets at the kernel layer — checkpoints when a subagent wanders.

LifecycleBudgetsSignalsSandbox

Multi-tenant AI products

SaaS where one tenant’s agents never touch another’s. Isolation is the first primitive, not a plugin.

Multi-tenancyVaultTelemetry

Local-first AI tooling

Ollama, LM Studio, on-disk memory, no hosted dependency. The same kernel on your laptop as in production — byte for byte.

OllamaLM StudioMemory

Agentic back-ends

MCP and A2A, client and server, in the same SDK. An event bus with circuit breakers keeps the graph honest.

MCPA2AIPC

§03Operational fit

Isolation, durability, audit, and sovereignty stop being features when they become business-critical. These are the shapes the kernel was built to carry.

Financial services

Multi-tenant isolation day one. BYOK credentials through the vault. Every tool call and LLM decision emits an OTel-audited event. HITL gates on destructive operations. FSL-1.1-MIT keeps critical infrastructure off any vendor’s roadmap.

Multi-tenancyVaultHITLTelemetry

Industrial automation

Runs on-prem without a hosted service. Atomic checkpoints resume a line after a power cycle. Signals propagate cleanly across the device tree. No Docker, no daemon — boots on industrial PCs the same way it boots on a laptop.

DurabilitySignalsLocal-firstSandbox

Robotics R&D

OS-level sandboxes for risky tool execution. Budget caps stop a wandering policy from burning the wall. MCP wires into existing robotics stacks; a dedicated computer-use driver with its own sandbox profile is on the v0.4 roadmap.

SandboxBudgetsMCPComputer-use

Regulated enterprise

On-prem by design — no hosted service, no data leaving the process. Persona identity lives in version control, not an admin UI. Tenant-scoped stores, vaults, connectors. Per-iteration checkpoints for long-running compliance reviews and document pipelines.

PersonasMulti-tenancyVaultCheckpoints

§04Four agent patterns

Namzu ships four agent shapes. Same lifecycle manager, same limit checker, same bus, same verification gate — switching patterns never trades safety for form.

Reactive

ReactiveAgent

Canonical

The canonical loop. Prompt → LLM → tool call(s) → iterate → stop. Budgets, HITL, progressive disclosure, compaction, and checkpoints — wired automatically.

Pipeline

PipelineAgent

Deterministic

Deterministic sequential steps. Output of step N is input of step N+1. Rolls back on failure. ETL, RAG ingestion, multi-stage document processing.

Router

RouterAgent

Classify & delegate

An LLM classifies the input and delegates to the best-suited agent from a configured set — with a fallback. Support triage, dispatcher bots, multi-expert systems.

Supervisor

SupervisorAgent

Spawn & coordinate

Coordinator that spawns specialised children, tracks the parent/child/depth hierarchy, aggregates results, and honours the shared budget tracker.

Or your own — extends AbstractAgent

These four are the shapes most workloads want. When your loop is different, subclass AbstractAgent directly — lifecycle, budgets, signals, compaction, and checkpointing still apply.

§05Subsystems

Twenty-four subsystems live inside @namzu/sdk. Nine of them, at a glance.

Sandbox

Deny-default I/O, scoped network, enforced resource limits. Seatbelt and namespaces — no Docker, no daemon.

Lifecycle

Parents spawn children. Children get budget slices. Isolation is in the fork.

Scheduling

Per-run token, cost, wall-clock, and iteration budgets. One policy engine decides what runs next.

Signals

One AbortController tree spans the whole subtree. Cancel, pause, resume — propagated cleanly.

Memory

Working memory compacts. Long-term memory persists, indexed by tag, query, status. No vector database required.

Durability

Atomic per-iteration checkpoints. Emergency core-dump on signal. Separate stores for runs, threads, memories, tasks.

IPC

Native A2A and MCP — client and server, one SDK. An event bus with circuit breakers and edit-ownership tracking underneath.

Providers

Narrow LLMProvider interface with a typed registry. Vendors swap at the import line.

Multi-tenancy

Registries, vaults, configs, stores — all tenant-scoped. Two organisations share a process, never each other’s state.

§06How Namzu compares

Framework category tells you what job the project actually does. Namzu is the only agent kernel in the set — and the feature map shows where that lives in code.

Criterion	Namzu	LangGraph	CrewAI	Mastra	Vercel AI SDK	OpenAI Agents SDK
Category	Agent Kernel	Graph framework	Crew framework	TS app framework	Frontend-first SDK	Vendor SDK
Language	TypeScript	Python/JS	Python	TypeScript	TypeScript	Python/JS
Process sandbox (OS-level)
Multi-tenant from day 1				partial
Sub-agent spawn (fork/exec)		via graph	crews			handoffs
Signal propagation tree				partial
Resource quotas (token / cost / time)		manual	manual	manual		manual
Checkpoint + resume		superstep		partial		sessions
Emergency save on signal
Thread ↔ Run separation						partial
Structured context compaction				partial
RAG built into the kernel		integrations	integrations	plugin		via tools
Native A2A protocol
Native MCP (client + server)		plugin		client		client
Progressive tool disclosure
Tool-call verification gate			task-level		approval
Persona inheritance (YAML)			role strings	partial		instructions
Advisory (multi-advisor)
File ownership / edit locking
Circuit breakers on the bus
Provider lock-in	none	low	low	low	low	OpenAI-first

Read the full comparison for each:LangChain Mastra Vercel AI SDK CrewAI AutoGPT-style runtimes All comparisons

§07Packages

One narrow LLMProvider interface. Seven implementations. Plus capability packages for the surfaces that live outside the chat boundary.

LLM providers

Ollama

in repo

@namzu/ollama

Local-first, zero-config. Default starting point.

LM Studio

in repo

@namzu/lmstudio

Local WebSocket inference for Apple Silicon.

Anthropic

in repo

@namzu/anthropic

Claude via Messages API. Prompt-caching aware.

OpenAI

in repo

@namzu/openai

GPT via Chat Completions.

Bedrock

in repo

@namzu/bedrock

AWS Bedrock Converse — Claude, Llama, Titan.

OpenRouter

in repo

@namzu/openrouter

Aggregated access to hundreds of models.

HTTP

in repo

@namzu/http

Zero-dep generic adapter for OpenAI- or Anthropic-compatible endpoints.

Or implement LLMProvider yourself.

The interface is narrow by design. Add your internal gateway, your on-prem model, or whatever comes next.

Capability packages

Computer use

published

@namzu/computer-use

Subprocess-based ComputerUseHost — screenshot, mouse, keyboard. Isolated from the host process, spawned per run, contract shipped by @namzu/sdk.

Voice & multimodal, on the roadmap.

STT/TTS driver, MIME-typed binary handles for image, audio, video — all on v0.4.

All integrations

§08Frequently asked

Direct answers to the questions developers ask before adopting an agent runtime.

What is Namzu?: Namzu is an open-source TypeScript agent kernel and SDK for building AI agents. It owns the runtime layer beneath agent frameworks — process lifecycle, scheduling, memory, IPC, sandboxing, and checkpoint/resume.
What is an agent kernel, and how is it different from an agent framework?: A kernel owns the runtime: how an agent process is created, isolated, scheduled, paused, resumed, and persisted. A framework owns composition: how prompts, tools, and graphs fit together. Namzu is the kernel; LangGraph, CrewAI, and Mastra-style frameworks sit above it.
What languages does Namzu support?: TypeScript today, via @namzu/sdk on Node.js. The kernel specification is portable by design — Rust, Go, and Python kernels sharing the same spec are on the public roadmap.
How does Namzu compare to LangChain or LangGraph?: LangChain and LangGraph are orchestration layers — they describe what an agent does. Namzu is the layer underneath — it describes how the agent runs. The two are complementary; an agent built on LangGraph could run on a Namzu kernel for sandboxing, scheduling, and checkpointing.
Is Namzu vendor-locked to a specific LLM provider?: No. The kernel exposes a narrow LLMProvider interface; provider integrations live in sibling packages (@namzu/anthropic, @namzu/openai, @namzu/openrouter, @namzu/bedrock, @namzu/ollama, @namzu/lmstudio, @namzu/http). No model is a citizen of the core.
Can I self-host Namzu?: Yes — Namzu is the kernel, not a hosted service. Install @namzu/sdk from npm and run it on your own infrastructure. There is no cloud component, no hosted control plane, and no required telemetry.
What license is Namzu under?: Namzu is released under FSL-1.1-MIT — free to run, fork, extend, and commercialise. The license is designed to convert to MIT after two years.
Where do I report bugs or request features?: On GitHub Issues. Decisions about the kernel land as ADRs in the same repo before they ship — the direction is visible before the code.

§08 · The manifesto

Every agent, its own kernel.

A rented kernel is not a kernel. Namzu is FSL-1.1-MIT because the runtime of autonomous software must be forkable, or the software is not autonomous at all.

Read the manifesto