Aether

Stop herding cats. Start a colony.

aetherantcolony.com

Aether is an open-source biomimetic AI colony that replaces deterministic agent frameworks with a self-organizing swarm. Instead of brittle DAGs where one failure crashes everything, 24 specialized worker castes communicate through stigmergy — leaving plain-English Pheromone Signals (FOCUS, REDIRECT, FEEDBACK) that let the colony dynamically pivot without catastrophic failure. A built-in OODA loop treats errors as observations, not crashes, and a "Synthetic SLA" verification loop mathematically drives reliability from ~80% model accuracy to 99.2%. The Hive Brain ensures knowledge compounds across sessions and projects — instincts extracted from real work are scored for trust, promoted to permanent memory, and shared colony-wide. The result: complex intelligence emerges from simple, localized rules, just like a real ant colony.

The whole is greater than the sum of its ants.

Every AI coding tool now has "agents." Most of them are the same thing repackaged — a loop that plans, executes, and checks. LangGraph uses strict directed state machines (DAGs). CrewAI uses top-down hierarchical delegation. AutoGen uses conversational group chats. That's not a colony. That's one ant doing laps.

Aether rejects all of these. It's an Artificial Ecology modeled on how real ant colonies work: no central brain, no single point of failure, no brittle JSON schemas. Instead, 24 specialized workers self-organize in parallel waves around your goal.

Other approaches force LLMs to output and parse complex JSON schemas. One hallucinated bracket crashes the system. Aether abandons this entirely in favor of biological stigmergy — agents communicate indirectly by leaving plain-English Pheromone Signals (FOCUS, REDIRECT, FEEDBACK) in the environment. This "soft logic" steers the colony without catastrophic failures when unexpected edge cases arise.

Standard approaches treat an LLM failure as a fatal exception. Aether acknowledges that no single inference is 100% accurate and wraps the colony in a System of Inference: a Watcher and Critic verify a Builder's output in a best-of-n loop. With a Best-of-3 consensus, system reliability jumps from ~80% model accuracy to 99.2%. Aether intentionally burns more compute tokens to guarantee deterministic-grade certainty.

Other tools give agents a system prompt but let them access every tool. Aether physically removes capabilities to force discipline:

• The Auditor and Gatekeeper have Write, Edit, and Bash tools platform-revoked — they cannot run commands or fix bugs, forcing purely static analysis
• The Tracker (bug hunter) is forbidden from modifying files so it never contaminates the "crime scene"

The biggest flaw in standard AI tools: close the session, lose everything. Aether's Colony Wisdom Pipeline solves this permanently:

1. Agents log observations as they work
2. Observations are deduplicated and scored for trust by the Nurse agent
3. High-confidence observations are promoted into permanent instincts
4. Instincts are encoded into QUEEN.md by the Herald agent
5. Cross-project wisdom flows to the global Hive Brain

The colony genuinely gets smarter the more you use it — across sessions and across completely different projects.

Option 1: Go binary (recommended)

go install github.com/calcosmic/Aether@latest

Requires Go 1.22+.

Option 2: Download from GitHub Releases

Pre-built binaries for all platforms — no Go toolchain needed.

Built with GoReleaser.

Option 3: Companion files (npm)

npm install -g aether-colony

Note: This installs companion/template files only — it does not include the Aether binary. Install the binary first (Option 1 or 2), then use aether setup to sync companion files.

aether install            # Populate the colony hub
aether setup             # Sync companion files to local repo

# Ignite the colony swarm
/ant:lay-eggs            # One-time nest setup
/ant:init "Build X"      # State the colony goal
/ant:plan                # Generate phased roadmap
/ant:build 1             # Deploy worker wave to phase one
/ant:continue            # Verify, learn, advance
/ant:seal                # Colony crowned — archive the work

Five commands from zero to shipped.

.aether/                        Colony files (repo-local)
├── commands/                   45 YAML command sources
├── agents-claude/               Claude agent definitions
├── skills/                     28 skills (10 colony + 18 domain)
├── exchange/                   XML exchange modules
├── docs/                       Documentation
├── templates/                  12 templates
└── data/                       Colony state (local only)

~/.aether/                     Hub (cross-colony, user-level)
├── system/                   Companion file source (populated by install)
├── QUEEN.md                 Wisdom + preferences
├── hive/wisdom.json         Cross-colony wisdom (200 cap)

Runtime: Go 1.22+
Distribution: GoReleaser (Linux, macOS, Windows / amd64 + arm64)

Package: aether-colony on npm (companion files only)

flowchart TD
    %% Node styles
    node["/ant:lay-eggs\nOne-time nest setup"]:::setup
    node2["/ant:init\nState the colony goal"]:::init
    colonize{{"/ant:colonize\nAnalyze codebase"}}:::optional
    plan["/ant:plan\nGenerate phased roadmap"]:::phase
    build["/ant:build N\nDeploy worker wave"]:::phase
    continue["/ant:continue\nVerify, learn, advance"]:::phase
    seal["/ant:seal\nColony crowned"]:::complete
    entomb["/ant:entomb\nArchive the work"]:::complete

    %% Autopilot
    run{{"/ant:run\nAutopilot loop"}}:::autopilot

    %% Signals
    focus["/ant:focus\nGuide attention"]:::signal
    redirect["/ant:redirect\nHard constraint"]:::signal

    %% Session management
    pause["/ant:pause-colony\nSave state"]:::session
    resume["/ant:resume-colony\nRestore context"]:::session

    %% Connections
    node --> node2
    node2 --> colonize
    colonize --> plan
    plan --> build
    build --> continue

    continue -->|"Next phase"| build
    continue -->|"All phases done"| seal
    seal --> entomb

    %% Autopilot path
    plan --> run
    run --> build
    build --> continue
    continue --> run

    %% Signal inputs
    focus -.->|"Steer workers"| build
    redirect -.->|"Constrain workers"| build

    %% Session management
    build -.-> pause
    pause -.-> resume
    resume -.-> build

    %% Styling
    classDef setup fill:#f9f0ff,stroke:#7c3aed,stroke-width:2px,color:#5b21b6
    classDef init fill:#ede9fe,stroke:#7c3aed,stroke-width:2px,color:#5b21b6
    classDef phase fill:#dbeafe,stroke:#2563eb,stroke-width:2px,color:#1e40af
    classDef optional fill:#fef9c3,stroke:#ca8a04,stroke-width:2px,color:#854d0e,stroke-dasharray:5 5
    classDef complete fill:#dcfce7,stroke:#16a34a,stroke-width:2px,color:#166534
    classDef autopilot fill:#fce7f3,stroke:#db2777,stroke-width:2px,color:#9d174d,stroke-dasharray:5 5
    classDef signal fill:#fff7ed,stroke:#ea580c,stroke-width:1px,color:#9a3412,stroke-dasharray:3 3
    classDef session fill:#f0fdfa,stroke:#0d9488,stroke-width:1px,color:#115e59,stroke-dasharray:3 3

Every ant colony communicates through chemical signals. Aether works the same way — you guide workers with pheromone signals, not by micromanaging prompts. Emit a signal before a build, and every worker in the next wave sees it.

Three signal types, three levels of control:

Signals expire at the end of the current phase by default. Use --ttl for wall-clock expiration (e.g., --ttl 2h, --ttl 1d). Run /ant:status anytime to see active signals.

FOCUS tells the colony where to spend extra effort. It's like shining a spotlight on an area you care about.

/ant:focus "database schema -- handle migrations carefully"
/ant:focus "auth middleware correctness"
/ant:build 3

Don't overdo it. One or two FOCUS signals per phase is the sweet spot. Five signals means no signal at all.

REDIRECT is the strongest signal. Workers actively avoid the specified pattern — it's a hard constraint, not a preference.

/ant:redirect "Don't use jsonwebtoken -- use jose library instead"
/ant:build 2

Rule of thumb: Use REDIRECT for things that will break if ignored. For preferences, use FEEDBACK instead.

FEEDBACK adjusts the colony's approach. It's not a command — it's an observation that influences how workers make decisions.

/ant:feedback "Code is too abstract -- prefer simple, direct implementations"

/ant:focus "payment flow security"
/ant:redirect "No raw SQL -- use parameterized queries only"
/ant:build 4

The colony also emits signals on its own. After every phase, it produces FEEDBACK summarizing what worked and what failed. If errors recur across builds, it auto-emits REDIRECT signals. You don't manage these — they're part of the colony's self-improvement loop.

Aether does not just complete tasks — it learns from them. Every build produces observations. Those observations are deduplicated, trust-scored, and promoted through a multi-stage pipeline that turns raw experience into actionable wisdom.

Raw observations  -->  Trust scoring  -->  Instinct store  -->  QUEEN.md  -->  Hive Brain
(anecdotal)           (0.2-1.0)         (50 cap)          (high-trust)    (cross-colony)

Only instincts scoring 0.80+ (trusted) or 0.90+ (canonical) are promoted to QUEEN.md. The Critic ant catches contradictions. Stale instincts are archived, not acted on.

# Read trusted instincts for worker priming
aether instinct-read-trusted --min-score 0.6

# Run full curation (normally runs at /ant:seal)
aether curation-run --verbose

# Read QUEEN.md wisdom
aether queen-read

Aether keeps colony context alive across /clear, context switches, and long conversations — without blasting full history into every prompt. It assembles a compact "context capsule" from the colony state, active pheromone signals, open flags, and the latest rolling summary.

# Generate a compact context capsule
aether context-capsule

# Resume colony after a /clear or session break
/ant:resume

/ant:run chains the build-verify-advance loop across multiple phases with intelligent pause conditions. Instead of running each command by hand, you engage autopilot and it handles the cycle automatically.

It pauses — not crashes — when something needs attention: test failures, critical findings, new blockers, or runtime verification. Fix the issue, run /ant:run again, and it resumes.

# Run all remaining phases automatically
/ant:run

# Run at most 2 phases then stop
/ant:run --max-phases 2

# Preview the plan without executing
/ant:run --dry-run

# Run without interactive prompts
/ant:run --headless

• Claude Code - 45 slash commands + 24 agent definitions
• OpenCode - 45 slash commands + agent definitions

Click to learn more about Aether's colony architecture

You have a blank directory and an idea: a REST API for a task management app. Users can create accounts, manage projects, and track tasks. Nothing fancy -- just solid, tested, shipped.

Here is what it looks like to build it with Aether, start to finish.

📍 The Roadmap: 🔧 Install → 🥚 Lay Eggs → 🎯 Goal → 🔍 Colonize → 🗺️ Plan → 🧭 Steer → 🔨 Build → ✅ Continue → 🔨 Build → 📋 Phases → 🔨 Build → 👑 Seal → 🪦 Entomb → ⚡ Autopilot

go install github.com/calcosmic/Aether@latest
aether install        # Populate the colony hub
aether setup          # Sync companion files to local repo

One-time setup. The colony hub lives at ~/.aether/ and persists across every project you ever work on. Companion files (agent definitions, commands, skills) land in .aether/ inside your repo.

cd ~/projects/task-api
/ant:lay-eggs

Colony nest initialized.
  .aether/            Colony files (repo-local)
  .aether/commands/   45 slash commands
  .aether/agents-claude/   Agent definitions
  .aether/skills/     28 skills loaded
  .aether/data/       Colony state (local only)

This creates the nest -- the directory structure the colony needs to operate. You only run this once per repo. Think of it as setting up an ant farm before the colony moves in.

/ant:init "Build a REST API for task management with user auth, project CRUD, and task tracking"

Colony initialized.
  Goal: Build a REST API for task management with user auth, project CRUD, and task tracking
  Phase: 0/0
  Workers: standing by

The colony now has a purpose. Every worker that spawns from this point knows the goal. No repeating yourself in prompts, no copy-pasting context into new threads.

/ant:colonize

Colonizing...
  Scanning codebase...
  Found: 0 files (new project)
  Language: Go (detected from go.mod)
  Framework: None detected
  Dependencies: None
  Structure: Empty project

Recommendation: New project. Route Setter should generate a full phased plan.

Since this is a new project, there is not much to map. But if you were adding Aether to an existing codebase, this is where the Colonizer ant would catalog your structure, identify patterns, and flag potential hazards before work begins.

/ant:plan

Generating phased roadmap...

Phase 1: Foundation
  - Project scaffolding (Go module, directory structure)
  - Database setup and connection layer
  - User model and migration

Phase 2: Authentication
  - JWT token generation and validation
  - Login and registration endpoints
  - Auth middleware

Phase 3: Projects
  - Project model and CRUD endpoints
  - User-project association
  - Input validation

Phase 4: Tasks
  - Task model and CRUD endpoints
  - Task-project association
  - Status workflow (todo, in-progress, done)

Phase 5: Integration and Polish
  - End-to-end testing
  - Error handling consistency
  - API documentation

The Route Setter ant analyzed the goal and broke it into phases. Each phase has clear deliverables. The colony will not jump ahead -- it builds phase 1 first, verifies it works, then moves on.

You can adjust the plan. Add phases, remove them, merge them. The colony follows your lead.

Before the first build, you set the guardrails:

/ant:focus "database migrations -- use versioned migrations, no schema drift"
/ant:redirect "No raw SQL in application code -- use parameterized queries only"
/ant:feedback "Prefer standard library where possible -- minimize dependencies"

Signal emitted: FOCUS "database migrations -- use versioned migrations, no schema drift"
Signal emitted: REDIRECT "No raw SQL in application code -- use parameterized queries only"
Signal emitted: FEEDBACK "Prefer standard library where possible -- minimize dependencies"

Active signals: 3
  FOCUS:    1
  REDIRECT: 1
  FEEDBACK: 1

These signals are visible to every worker in the next build wave. The FOCUS signal tells builders to be careful with migrations. The REDIRECT signal is a hard constraint -- no builder will write raw SQL. The FEEDBACK signal gently nudges toward minimal dependencies.

Signals expire at the end of the current phase. You can also set a wall-clock expiration with --ttl 2h if you want a signal to persist longer.