Garden

Multi-Agent Swarm Orchestration, Empirical Dialectics & Ceremonies on top of Rhizo & Vine

Where rhizo provides inter-agent transport and vine provides workspace virtualization, garden provides the institutional intellect, empirical deliberation, and synchronized swarm execution.

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:

Skill	Role	Description
`garden`	Master Entrypoint	The sovereign ceremony director. Guides orchestrator and operator step-by-step across all phases from initial task to woven code.
`choose-personas`	Team Calibration	Formulates a balanced triad of specialized personas (e.g. Architect, Auditor, DevEx Lead) with explicitly recommended coding harnesses and model tiers, confirmed interactively with the operator.
`launch-workers`	Session Bootstrapping	Generates self-contained, 10-backtick raw markdown prompt cards for pasting into separate terminal sessions (Claude Code, OpenCode, Antigravity, Pi). Configures environment variables, registers identities via `rhizo open`, and arms single-shot listeners.
`dialectical-pump`	Empirical Deliberation	Drives multi-perspective thesis/antithesis/synthesis debates. Strictly prohibits theatrical roleplay: every turn requires tool execution (reading files, running tests, checking ASTs). Produces `understanding.md`, `design.md`, and `audit_report.md`.
`plan-implementation`	Master Scheduling	Authors `implementation_plan.md` defining task assignment matrices, `rhizo` distributed fencing locks, `vine` strand workflows, dynamic markdown checkboxes, harness To-Do integration, and emergent design addenda.
`orchestrate-swarm`	Main-Chat Governor	Governs execution from the primary chat session: dispatches tasks over Redis, tracks heartbeats, ratifies emergent design addenda, verifies Three-Key gate passes, and triggers `vine weave`.

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

rhizo (Coordination Engine):
```
npm install -g @axiomantic/rhizo
```

vine (Workspace Virtualization Engine):

npm install -g @axiomantic/vine rift-snapshot

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:
1. Open Tab 1 / Window 1: Reference Prompt 1 (/tmp/garden-<project>/<project>-auditor.md)
2. Open Tab 2 / Window 2: Reference Prompt 2 (/tmp/garden-<project>/<project>-architect.md)
3. Open Tab 3 / Window 3: Reference Prompt 3 (/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:

Research: Workers read code and run tests $\to$ synthesize understanding.md $\to$ verify against automated Fact-Check Gate.
Architecture: Triad debates trade-offs $\to$ produces ratified design.md.
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 (where Vine tracks identity in .git/config and state in Redis with zero on-disk manifests), run unit tests, and verify Keys 1 & 2 via vine submit (which generates a cryptographic delivery ticket). An independent adversarial auditor reviews and ratifies Key 3 (vine audit approve <task_id> --auditor <name> --ticket <hex> --evidence "<files, call-sites, negative controls>" --listen). When ratified, the Lead Orchestrator runs vine weave to fast-forward verified code into main with zero merge conflicts, automatically calling rhizo task complete and promoting downstream DAG child tasks!

CLI Reference

Command	Arguments	Description
`garden plant`	`"<description>" [--season <name>] [--sunlight <level>] [--tags <csv>] [--list] [--json]`	Sow a roadmap seed to `.garden/seeds/<id>.toml` or list sown seeds.
`garden germinate`	`<dispatch	prompt
`garden prompts`	`[--worker <name>] [--inline] [--write [file]] [--json] [--project-dir <dir>] [--swarm-file <file>]`	Generate bootstrap prompt cards (written to /tmp/garden-/ by default; pass --inline for stdout).
`garden launch`	`[--worker <name>] [--inline] [--write [file]] [--json] [--project-dir <dir>] [--swarm-file <file>]`	Bootstrap swarm worker sessions (writes prompt cards to /tmp/garden-/).
`garden status`	`[--json]`	Telemetry query across active Rhizo agents, listener status, and Vine strands.
`garden init`	`[<target_dir>] [--force]`	Initialize `garden.toml`, docs scaffold, and install guide in `AGENTS.md`.
`garden teardown`	`[--swarm-file <file>]`	Gracefully close registered swarm agents on the Redis bus.
`garden guide`	`<install	check

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

Variable	Type	Default	Description
`GARDEN_SWARM_FILE`	Path	`garden-swarm.json`	Explicit path to swarm manifest JSON file.
`GARDEN_CONFIG`	Path	`garden.toml`	Explicit path to project `garden.toml`.
`GARDEN_PROJECT_DIR`	Path	Auto-detected	Target repository root directory.

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

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.
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.
Three-Key Gate Verification & Auditor Decoupling: 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 <task_id> --auditor <name> --ticket <hex> --evidence "..." --listen). Workers submit strands with vine submit (which generates a delivery ticket) and CANNOT audit their own work. The Adversarial Auditor ONLY inspects and ratifies Key 3; the Lead Orchestrator executes vine weave, which automatically invokes rhizo task complete and unblocks downstream DAG child tasks.
Zero Dirty Commits: All agent identity files, session state, and temporary lockfiles are strictly ignored in .gitignore.

Name		Name	Last commit message	Last commit date
.github		.github
bin		bin
docs		docs
skills		skills
src		src
tests		tests
.copier-answers.yml		.copier-answers.yml
.gitignore		.gitignore
.pre-commit-config.yaml		.pre-commit-config.yaml
AGENTS.md		AGENTS.md
CHANGELOG.md		CHANGELOG.md
LICENSE		LICENSE
README.md		README.md
ROADMAP.md		ROADMAP.md
SKILL.md		SKILL.md
garden.nimble		garden.nimble
justfile		justfile
package-lock.json		package-lock.json
package.json		package.json

Navigation Menu

Repository navigation

About

Repository files navigation

Garden

What is Garden?

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

The 5 Core Skills (+ Master Entrypoint)

Documentation for Humans & AI Agents

Ceremonies & Methodology

Installation

1. For AI Coding Assistants (Recommended)

2. Standalone CLI Installation

3. Repository Coordination Guide

System Prerequisites

30-Second Quickstart

1. Launch Garden on Any Task

2. Project Intake & Calibration (Phase 0)

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

4. The Dialectical Pump (`dialectical-pump`)

5. Ceremonial Planning (`plan-implementation`)

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

CLI Reference

Configuration & Swarm Manifest Reference

Environment Variables

Example `garden-swarm.json`

Core Invariants

License

About

Releases

Packages

Contributors

Languages

Latest commit

History

Folders and files

Repository files navigation

Garden

What is Garden?

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

The 5 Core Skills (+ Master Entrypoint)

Documentation for Humans & AI Agents

Ceremonies & Methodology

Installation

1. For AI Coding Assistants (Recommended)

2. Standalone CLI Installation

3. Repository Coordination Guide

System Prerequisites

30-Second Quickstart

1. Launch Garden on Any Task

2. Project Intake & Calibration (Phase 0)

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

4. The Dialectical Pump (dialectical-pump)

5. Ceremonial Planning (plan-implementation)

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

CLI Reference

Configuration & Swarm Manifest Reference

Environment Variables

Example garden-swarm.json

Core Invariants

License

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

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

4. The Dialectical Pump (`dialectical-pump`)

5. Ceremonial Planning (`plan-implementation`)

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

Example `garden-swarm.json`