What is Garden?

Garden is an agentic engineering framework and skill library for orchestrating heterogeneous teams of AI coding assistants (Claude Code, OpenCode, Antigravity, Cursor, Codex).

[!NOTE]

Quick Note: Using Garden as your High-Level Swarm Wrapper

Garden is the sovereign high-level multi-agent wrapper for all your engineering projects.
After installing @axiomantic/garden, @axiomantic/rhizo, and @axiomantic/vine, you don't need complex shell scripts, background daemon managers, or brittle terminal multiplexers. Whenever you start a session in your favorite coding harness (Antigravity, Claude Code, OpenCode, Cursor), simply tell the assistant:

"garden: I want to build [feature/system/project]"

The session automatically acts as the Lead Orchestrator. It auto-detects your coding harness and conducts a single-question intake interview to calibrate your desired team shape and session-default models. It then configures your project (garden.toml & garden-swarm.json) and writes prompt cards to files for you to manually assign to new or existing chat sessions. Garden coordinates the entire swarm over Rhizo (local Redis message bus) and Vine (isolated Rift copy-on-write workspaces)!

Instead of treating AI agents as isolated single-turn chatbots, Garden provisions prompt-bootstrapped worker swarms across your favorite AI coding harnesses (Claude Code, OpenCode, Antigravity, Pi, Cursor), balances specialized personas with designated foundation models, drives empirically grounded dialectical deliberation, schedules distributed fencing mutexes, and integrates code through isolated Rift copy-on-write strands verified by Vine's Three-Key Gate.

flowchart TD
    subgraph Layer3["Layer 3: Garden (Methodology, Ceremonies & Swarms)"]
        direction TB
        GardenSkill["garden (Master Entrypoint)"]
        P1["choose-personas (Team & Models)"]
        P2["launch-workers (Prompt-Based Session Bootstrapping)"]
        P3["dialectical-pump (Research ➔ Design ➔ Audit)"]
        P4["plan-implementation (Locks & Strands)"]
        P5["orchestrate-swarm (Dispatch & Weave)"]
        GardenSkill --> P1 --> P2 --> P3 --> P4 --> P5
    end

    subgraph Layer2["Layer 2: Vine (Workstream Integrator)"]
        Strands["Rift Strands (Zero-cost copy-on-write workspaces)"]
        TwoKey["Three-Key Gate (Mechanical + Semantic + Independent Audit)"]
        Weave["Trunk Weaving (Fast-forward verified branches)"]
    end

    subgraph Layer1["Layer 1: Rhizo (Inter-Agent Transport)"]
        Bus["Redis Message Bus (O2O, Multicast, RPC)"]
        Locks["Distributed Mutexes & Monotonic Fencing Tokens"]
        Queues["Worker Queues with Leases & Dead-Letter Escalation"]
    end

    Layer3 --> Layer2
    Layer3 --> Layer1
    Layer2 -.-> Layer1

The 5 Core Skills (+ Master Entrypoint)

Garden is organized into a clean, batteries-included catalog of self-explanatory skills:

Documentation for Humans & AI Agents

Garden provides comprehensive ceremony, manifest, and protocol specifications:

Ceremonies & Methodology

• Ceremony Lifecycle Specification: The 6 sequential ceremony phases, quality gates, and sovereign session bootstrapping.
• Swarm Manifest Schema: JSON/TOML specification for garden-swarm.json and garden.toml.
• Dialectical Pump Protocol: Grounded multi-perspective debate, Stage 1-3 deliverables, and the Emergent Design Addendum Protocol.
• CLI Reference Manual: Complete catalog of Garden commands (init, prompts, launch, status, teardown).
• Configuration Architecture: Project-level configuration, strand options, and test runner configurations.
• Agent Constitution & Invariants (AGENTS.md): Coordination invariants, sovereign session rules, and listener discipline.

Installation

1. For AI Coding Assistants (Recommended)

Install the skills globally (-g) across all your coding assistants (Claude Code, Antigravity, Cursor, Codex, OpenCode, etc.):

# Recommended: Install the complete multi-agent triad globally
npx skills add -g axiomantic/rhizo
npx skills add -g axiomantic/vine
npx skills add -g axiomantic/garden

(Each skill automatically self-bootstraps its native CLI binary if it is not already installed on your system).

To install only Garden (includes the 6 Garden skills):

npx skills add -g axiomantic/garden

2. Standalone CLI Installation

Install the compiled CLI tools directly onto your $PATH:

# Recommended: Install Garden (automatically carries rhizo, vine, and rift bin riders):
npm install -g @axiomantic/garden

# Or install individual components explicitly if desired:
npm install -g @axiomantic/rhizo @axiomantic/vine @axiomantic/garden rift-snapshot

[!TIP] All-In-One Toolchain: @axiomantic/garden carries first-class bin riders for garden, rhizo, vine, and rift. Installing @axiomantic/garden makes all four commands immediately accessible in your $PATH.

In restricted or containerized environments where global installation is unavailable, you can run any command directly without installing:

npx -y @axiomantic/garden <command>

3. Repository Coordination Guide

Install the Garden multi-agent swarm coordination protocol directly into any project's AGENTS.md:

garden guide install

System Prerequisites

1. rhizo (Coordination Engine):

   npm install -g @axiomantic/rhizo
   

2. vine (Workspace Virtualization Engine):

   npm install -g @axiomantic/vine rift-snapshot
   

3. Redis or Valkey (local or remote):

   brew install redis && brew services start redis
   

30-Second Quickstart

1. Launch Garden on Any Task

In your primary AI coding assistant (Antigravity, Claude Code, OpenCode):

User: "garden: Implement high-throughput batch claim leases with Redis pipeline support"

2. Project Intake & Calibration (Phase 0)

Garden utilizes the Active Swarm Fast-Path (First-Look Invariant):

• Existing Cluster Online: Before asking intake questions, Garden runs rhizo who --json. If active, healthy workers already exist on the cluster, Garden skips all setup questions and prompt cards, automatically attaching to the active workers to proceed straight to task planning or execution!
• Cold Start (Zero Active Workers): If no workers are online, the Orchestrator auto-detects the active coding harness (ANTIGRAVITY_APP_DIR, CLAUDE_CODE, OPENCODE_SESSION_ID, CODEX_SESSION_ID, PI_SESSION_ID) and conducts a single-question intake interview:
  1. Execution Mode & Swarm Shape in : Multi-Agent Swarm (Balanced Triad or Focused Duo in the detected harness) vs Single-Agent Inline.

[!IMPORTANT] Universal Sovereign Sessions & Model Inheritance:

• Sovereign Sessions Only (Universal Subagent & Tmux Prohibition): Swarm workers are strictly independent sessions (separate terminal tabs or IDE windows) bootstrapped via 10-backtick prompt cards. Harness-internal subagents (e.g. Antigravity's invoke_subagent, Claude Code's Task, OpenCode subtasks) and terminal multiplexers (tmux) are strictly prohibited.
• Session-Native Model Inheritance: Swarm workers inherit whatever foundation model is active in that harness window (Session Default (active in window/tab)). Disconnected model pairing quizzes are eliminated.

3. Prompt-Based Swarm Bootstrapping (launch-workers)

Garden writes garden-swarm.json and runs garden prompts to write prompt cards directly to temporary files (/tmp/garden-<project>/<worker>.md) rather than flooding the chat window with thousands of lines of raw text:

• The Orchestrator displays concise session assignments with clickable file links and OS copy commands:
  1. Open Tab 1 / Window 1: Paste Prompt 1 (pbcopy < /tmp/garden-<project>/<project>-auditor.md)
  2. Open Tab 2 / Window 2: Paste Prompt 2 (pbcopy < /tmp/garden-<project>/<project>-architect.md)
  3. Open Tab 3 / Window 3: Paste Prompt 3 (pbcopy < /tmp/garden-<project>/<project>-implementer.md)
• Each session enters the project directory, exports RHIZO_AGENT_NAME, registers on the Redis bus (rhizo open), and arms its single-shot listener (rhizo listen).
• The Orchestrator confirms all workers are live via rhizo who --json before dispatching tasks!

4. The Dialectical Pump (dialectical-pump)

The personas deliberate across three empirical stages:

1. Research: Workers read code and run tests $\to$ synthesize understanding.md $\to$ verify against automated Fact-Check Gate.
2. Architecture: Triad debates trade-offs $\to$ produces ratified design.md.
3. Audit: Auditor generates audit_report.md $\to$ triad resolves every finding before coding begins.

5. Ceremonial Planning (plan-implementation)

Garden authors implementation_plan.md:

• Schedules distributed fencing locks (rhizo lock file:<path> --fencing).
• Assigns tasks and provisions isolated Rift strands (vine new <task_id>).
• Sets up dynamic progress checkboxes and harness To-Do tracking.

6. Live Orchestration & Trunk Weaving (orchestrate-swarm)

The main chat orchestrator dispatches work over Redis. Workers code in isolated strands, run unit tests, and verify Keys 1 & 2 (vine submit). An independent adversarial auditor reviews and ratifies Key 3 (vine audit approve). When ratified, the orchestrator executes vine weave to fast-forward verified code into main with zero merge conflicts!

CLI Reference

Configuration & Swarm Manifest Reference

[!TIP] For the complete specification of garden.toml, garden-swarm.json schemas, and environment variables, see the Garden Configuration & Swarm Manifest Reference.

Environment Variables

Example garden-swarm.json

{
  "project": "myproject",
  "target_repo": "/Users/developer/Development/myproject",
  "orchestrator": "orchestrator",
  "workers": [
    {
      "name": "architect",
      "persona": "Bramblestitch (Systems Architect)",
      "role": "Systems Architect & Formal Invariant Specifier",
      "harness": "Claude Code",
      "model": "claude-3-5-sonnet",
      "tags": ["design", "spec"],
      "opposing_priority": "Formal mathematical correctness and zero architectural drift."
    },
    {
      "name": "auditor",
      "persona": "Prickle-Thistle (Adversarial Quality Auditor)",
      "role": "Adversarial Code Reviewer & Security Auditor",
      "harness": "OpenCode",
      "model": "gemini-3.8-flash",
      "tags": ["audit", "testing"],
      "opposing_priority": "Aggressive edge-case fault injection and invariant verification."
    },
    {
      "name": "implementer",
      "persona": "Moss-Weaver (Lead Implementation Engineer)",
      "role": "Polyglot Systems & Performance Engineer",
      "harness": "Antigravity",
      "model": "claude-3-5-sonnet",
      "tags": ["implementation", "perf"],
      "opposing_priority": "Rapid implementation velocity and minimal dependency footprint."
    }
  ]
}

Core Invariants

1. The Lead Orchestrator Invariant: The main chat session coordinates, reviews, and integrates. Intensive multi-file edits are executed by the worker fleet in isolated strands.
2. Empirical Grounding Protocol (Zero Theatrical Dialogue): Dialectical deliberations must cite hard evidence from real tool calls (line citations, test outputs, compiler errors). Theatrical roleplay is strictly banned.
3. Three-Key Gate Verification: No code is merged into the trunk without passing Key 1 (in-memory git merge-tree mechanical check), Key 2 (live semantic compiler and test suite run), and Key 3 (independent adversarial audit ratification via vine audit approve). Workers submit strands with vine submit and CANNOT audit their own work.
4. Zero Dirty Commits: All agent identity files, session state, and temporary lockfiles are strictly ignored in .gitignore.

License

MIT © Axiomantic / Garden Contributors