agent-zero is the AI runtime behind Vibe Studio. The repo at /Users/imzee/projects/agent-zero/ hosts two parallel implementations of the same model — a streaming agent loop, a pluggable tool registry, markdown-driven skills, persistent memory, and sub-agent composition. Both are real, both work, but they target different audiences.
a-full vs a-mini
| a-full | a-mini | |
|---|---|---|
| Language | TypeScript | Python |
| Lines | ~thousands of files in src/ | ~5000 |
| Audience | Production runtime | Reference / pedagogical reimplementation |
| UI | Ink-based terminal + dialog launchers | REPL only |
| Providers | Anthropic, OpenAI, Gemini, plus internal mux | Anthropic, OpenAI, Gemini, Kimi, Qwen, Zhipu, DeepSeek, Ollama, vLLM, LM Studio, custom OpenAI-compatible |
| Tool count | 30+ | 18 |
| Multi-agent | Yes | Yes (multi_agent/ package) |
| Memory | Yes | Yes (memory/ package) |
| Skills | Yes | Yes (skill/ package) |
| Worktree isolation | Yes | Yes |
| Compaction | Yes | Yes (compaction.py) |
| Discovery API integration | Yes | Yes |
a-full is what session-manager spawns when a builder opens a Vibe Studio workspace. It's the production runtime.
a-mini is what to read when you want to understand how agent-zero works. It maps cleanly to a-full's concepts but in fewer lines, in Python, with separable packages — agent.py, compaction.py, context.py, tool_registry.py, tools.py, multi_agent/, memory/, skill/, providers.py. If a-full's TypeScript is a black box to you, a-mini is the spec.
The a-mini README spells this out: "A minimal Python reimplementation of Claude Code in ~900 lines (initial version)." It's grown to 5000 lines with the multi-agent, memory, and skill packages, but the core remains a small, readable implementation.
When to use which
- You're writing custom skills, tools, or agent definitions — read a-mini first to understand the model. Once it clicks, the same patterns work in a-full (with TypeScript types).
- You want to run agent-zero outside Vibe Studio — both runtimes work. a-full is more featureful but heavier. a-mini fits in one process and a few env vars.
- You're debugging an agent in production — a-full is what's actually running. Read its source.
- You're writing AppMint integration code — either runtime. The discovery-API rules apply equally.
Shared concepts
Both runtimes share the same vocabulary. The rest of these docs use the a-mini source as the canonical reference because it's smaller and more readable, but the same names exist in a-full.
- Agent loop — multi-turn streaming conversation with the LLM. See Architecture.
- Tool registry — pluggable tools the agent can call. See Tools.
- Skills — markdown-driven prompt templates with argument substitution and inline / fork execution. See Skills.
- Memory — long-running context stored as markdown files, with user and project scopes. See Memory.
- Multi-agent — spawn typed sub-agents (coder, reviewer, researcher, tester) with optional worktree isolation. See Multi-agent.
- Discovery-first — for any AppMint integration, the agent calls
/discover/*before generating code. See Discovery API usage. - Compaction — long conversations are auto-compacted to stay within model context windows.
What's not in scope
a-mini bills itself as nano-claude-code; it's intentionally not a full Claude Code drop-in. Things that don't ship:
- Native dialogs and terminal UI polish — a-full has those, a-mini stays REPL-only.
- The Anthropic-specific extended thinking integration — a-mini has it, but only for Anthropic models.
- Built-in plan-mode / approval-mode UI — both runtimes support permission modes (
auto/accept-all/manual) but the UI is bare.
Self-hosting
Both runtimes can run outside Vibe Studio. a-mini is the easier starting point — pip install -r requirements.txt, set an API key, run python nano_claude.py. a-full requires the TypeScript build chain. See Self-hosting.
Read order
If you're starting fresh:
- Architecture — the loop, context, tool dispatch.
- Tools — register custom tools.
- Skills — markdown-driven prompt templates.
- Memory — long-running context.
- Multi-agent — sub-agent composition.
- Discovery API usage — the AppMint integration pattern.
- Self-hosting — run it outside Vibe Studio.