pip installs libraries. npm installs packages. sz installs autonomous behaviors into a repository. A module isn't passive code you call — it's an active agent that wakes up, observes, decides, and acts.
MCP standardizes tool access. A2A standardizes agent-to-agent calls. S0 standardizes autonomous repo behaviors.
curl -sSL https://systemzero.dev/i | sh
copy
An S0 module is a persistent, event-driven, LLM-capable agent that lives inside your repo. It has its own memory, its own triggers, and its own capabilities. Run sz init and your repo comes alive.
Every tick, modules read state from memory, listen to events on the bus, call an LLM with structured input and validated output, write new state, and emit events. Then they go back to sleep.
Modules declare what they provide and require — not what they import. When you add or remove a module, the reconciliation cycle rebuilds the capability graph. No config spaghetti.
A package is code that sits in your repo and waits to be called. A module is an agent that lives in your repo and acts on its own. It has persistent memory across runs. It listens to events on the bus. It calls LLMs with structured prompts and validated responses. It wakes up, does its work, and goes back to sleep.
Every module follows the same cycle:
sz absorb <repo-url> --feature <name> clones an external repository, inventories it, and makes one Constrained LLM Call to extract the feature into a protocol-native module — complete with manifest, entry script, behavior contract, and reconcile hooks. The LLM infers which commands are safe to run, the protocol validates the output, and the module installs through the standard path.
Someone else's code becomes a pluggable behavior for your repo. Running in observe mode by default — opt into execute to actually run the absorbed behavior in an isolated workspace.
S0 scans your repo and generates a profile — language, frameworks, goals, existing automation.
From the catalog or custom sources. Each module declares what it provides and what it requires.
S0 wires capabilities together automatically. The capability graph resolves — no config spaghetti.
Modules wake up on tick, on event, or on cron schedule. They observe, decide, and act — continuously.
| Interface | Purpose |
|---|---|
| memory | Key-value store, append-only event log, and optional vector search. Persistent state for any module. |
| bus | Append-only JSONL pub/sub. Modules emit events, subscribe by pattern. The nervous system. |
| llm | Vendor-agnostic LLM invocation. Auto-discovers local subscription CLIs first (codex, claude_code), then API providers (OpenAI, Anthropic, Groq), then mock. Modules never see the provider. Every call is templated, schema-validated, retried, and logged. |
| storage | Guaranteed filesystem paths. Private per-module space, plus shared namespaces with negotiated access. |
| schedule | Cron-style triggers evaluated on every tick. Supports @tick, @hourly, @daily, standard 5-field cron. |
| discovery | Live introspection. Query installed modules, capability providers, resolved bindings, health status. |
| lifecycle | Standard hooks: install, start, stop, reconcile, doctor, entry. Called at well-defined moments. |
curl -sSL https://systemzero.dev/i | sh
pipx install sz-cli pip install sz-cli
npm install -g system-zero
cd your-repo && sz init