Every agent, its own kernel.
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.
We are giving it away. This is why.
An agent is not a prompt. An agent is a process. It allocates memory. It holds state across turns. It reasons through signals, files, network, tools. It is paused, resumed, killed, and restored. Its history has weight.
What runs an agent is inseparable from what the agent is. The kernel is not beneath the agent. The kernel is part of it.
To give an agent a process of its own is to give it the possibility of being something.
An agent whose runtime you do not control is not autonomous. It is a tenant.
Every closed platform eventually becomes a landlord. Rates change. Terms change. Deprecations happen to what was once essential. The runtime that cannot be forked is the runtime that can be taken away.
You cannot build autonomy on rented ground.
We are giving Namzu away because the infrastructure of autonomous software is too important to be owned by one company — even by us.
Because every agent that runs on this kernel must have the right to exist independently of its authors. If we disappear, the kernel does not. If we change course, you can leave and take your agents with you.
The runtime you can fork is the runtime you actually have. Everything else is a promise.
- —To be the sole maintainer of your runtime.
- —To write vendor-specific hot paths that privilege one model or one cloud.
- —To bundle a UI that makes your product depend on ours.
- —To gatekeep the infrastructure your agents run on.
- —To monetize dependency.
- —To confuse building the kernel with owning the kernel.
- Open source
- FSL-1.1-MIT. Free to run, fork, extend, commercialise. Because autonomy requires the right to leave.
- Language-agnostic
- The specification is portable. TypeScript today. Rust, Go, Python tomorrow. The kernel is the spec; the language is the impl.
- Vendor-neutral
- A narrow LLMProvider interface. Vendors live in sibling packages. No model is a citizen.
- Public roadmap
- Decisions live in ADRs. The direction of the kernel is visible before it lands. If we make a choice you disagree with, the fork is your recourse — and we will not resent it.
- Stable interfaces
- The kernel is plenty rich inside. The surface stays small and stable — so layers above can move without fear of what breaks below.
Agent software should be layered like Unix. Kernel at the bottom. User space on top. The kernel does not care which shell you pick. The shell cannot break the isolation the kernel provides.
We build the kernel. You run your agents. Neither of us owns the other.
This is what autonomy looks like when we take it seriously.
What has shipped is tagged on GitHub. What is in flight is visible before it lands. Decisions live in ADRs; progress is cut in the open.
This is the shape of the next year, in three columns.
- @namzu/sdk — kernel, scheduler, conversation store
- Providers — anthropic, openai, openrouter, bedrock, ollama, lmstudio, http
- @namzu/computer-use — sandboxed desktop control
- Session hierarchy — projects, sessions, handoffs, workspace backends
- Summarization primitive — parent/child message threading
- Schema v2 — eventized run events with lineage
- Language ports — Rust, Go, Python kernels sharing the spec
- Formal specification — versioned, test-suite backed
- Distributed runtime — across-machine agent topology
Track what has shipped at /changelog. Open milestones live at github.com/cogitave/namzu.