animus-cli

_{AI agent orchestrator | autonomous coding agents | multi-model AI dev team | Claude + Gemini + GPT workflow automation | MCP integration | YAML-driven CI for AI | Rust CLI}

Install

curl -fsSL https://raw.githubusercontent.com/launchapp-dev/ao/main/install.sh | bash

The upstream installer currently targets macOS. On Linux and Windows, use a release archive or build from source.

# Specific version
AO_VERSION=v0.3.0 curl -fsSL https://raw.githubusercontent.com/launchapp-dev/ao/main/install.sh | bash

# Custom directory
AO_INSTALL_DIR=/usr/local/bin curl -fsSL https://raw.githubusercontent.com/launchapp-dev/ao/main/install.sh | bash

You need at least one AI coding CLI:

npm install -g @anthropic-ai/claude-code    # Claude (recommended)
npm install -g @openai/codex                # Codex
npm install -g @google/gemini-cli           # Gemini

What is Animus?

Animus turns a single YAML file into an autonomous software delivery pipeline.

You define agents, wire them into phases, compose phases into workflows, schedule everything with cron — and Animus's daemon handles the rest: dispatching tasks to AI agents in isolated git worktrees, managing quality gates, and merging the results.

                ┌──────────────────────────────────────────────────┐
                │            Animus Daemon (Rust)                  │
                │                                                  │
  ┌────────┐    │    ┌───────────┐    ┌───────────┐    ┌────────┐ │    ┌────────┐
  │ Tasks  │───▶│───▶│  Dispatch │───▶│  Agents   │───▶│ Phases │─│──▶│  PRs   │
  │        │    │    │  Queue    │    │           │    │        │ │    │        │
  │ TASK-1 │    │    │ priority  │    │ Claude    │    │ impl   │ │    │ PR #42 │
  │ TASK-2 │    │    │ routing   │    │ Codex     │    │ review │ │    │ PR #43 │
  │ TASK-3 │    │    │ capacity  │    │ Gemini    │    │ test   │ │    │ PR #44 │
  └────────┘    │    └───────────┘    └───────────┘    └────────┘ │    └────────┘
                │                                                  │
                │    Schedules: work-planner (5m), pr-reviewer     │
                │    (5m), reconciler (5m), PO scans (2-8h)        │
                └──────────────────────────────────────────────────┘

Quick Start

cd your-project                          # any git repo
animus doctor                            # check prerequisites and auto-remediate
animus init --template task-queue --non-interactive  # initialize .ao/ with a queue-first workflow template

# Option 1: Run workflows on demand
animus task create --title "Add rate limiting" --task-type feature --priority high
animus workflow run --task-id TASK-001

# Option 2: Go fully autonomous (v0.3.0+)
animus daemon start --autonomous         # continuous execution with event triggers

v0.3.0: Autonomous Mode is Production-Ready

The daemon now runs as your primary software delivery engine. Enable event triggers, cloud sync, and automatic quality gates:

animus config set daemon.autonomous true
animus config set cloud.sync enabled
animus daemon start                      # runs forever, responds to webhooks and cron

Cloud Integration (v0.3.0+)

Sync your Animus state to a cloud backend for team visibility, distributed execution, and webhook-driven automation.

animus cloud login                       # authenticate with your workspace
animus cloud sync --status               # check sync status
animus config set cloud.webhook-url "https://your-domain.com/webhook"

Features:

• Team Sync: All team members see the same task queue, execution logs, and run history
• Webhook Triggers: GitHub, Linear, Slack, and custom webhooks trigger workflows automatically
• Distributed Daemon: Run multiple daemon instances across regions with automatic failover
• Execution Timeline: Inspect runs, decisions, and agent reasoning in the cloud dashboard

Everything in One YAML

agents:
  default:
    model: claude-sonnet-4-6
    tool: claude
    mcp_servers: ["animus", "context7"]

  work-planner:
    system_prompt: |
      Scan tasks, check dependencies,
      enqueue ready work for the daemon.
    model: claude-sonnet-4-6
    tool: claude

phases:
  implementation:
    mode: agent
    agent: default
    directive: "Implement production code."
    decision_contract:
      min_confidence: 0.7
      max_risk: medium

  push-branch:
    mode: command
    command:
      program: git
      args: ["push", "-u", "origin", "HEAD"]

workflows:
  - id: standard
    phases:
      - requirements
      - implementation
      - push-branch
      - create-pr
    post_success:
      merge:
        strategy: squash
        auto_merge: true
        cleanup_worktree: true

schedules:
  - id: work-planner
    cron: "*/5 * * * *"
    workflow_ref: work-planner
    enabled: true

triggers:
  - id: pr-opened
    event: "github.pull_request.opened"
    workflow_ref: pr-reviewer
  
  - id: task-updated
    event: "linear.issue.updated"
    workflow_ref: work-planner

The Full Agent Team

Animus doesn't run one agent. It runs an entire product organization:

  ┌─────────────────────────────────────────────────────────────────┐
  │                                                                 │
  │   Planners               Builders              Reviewers        │
  │   ╭──────────────╮       ╭──────────────╮       ╭──────────────╮│
  │   │ Work Planner │       │ Claude Eng   │       │ PR Reviewer  ││
  │   │ Reconciler   │       │ Codex Eng    │       │ PO Reviewer  ││
  │   │ Triager      │       │ Gemini Eng   │       │ Code Review  ││
  │   │ Req Refiner  │       │ GLM Eng      │       │              ││
  │   ╰──────────────╯       ╰──────────────╯       ╰──────────────╯│
  │                                                                 │
  │   Product Owners         Architects             Operations      │
  │   ╭──────────────╮       ╭──────────────╮       ╭──────────────╮│
  │   │ PO: Web      │       │ Rust Arch    │       │ Sys Monitor  ││
  │   │ PO: MCP      │       │ Infra Arch   │       │ Release Mgr  ││
  │   │ PO: Workflow │       │              │       │ Branch Sync  ││
  │   │ PO: CLI      │       │              │       │ Doc Drift    ││
  │   │ PO: Runner   │       │              │       │ Wf Optimizer ││
  │   ╰──────────────╯       ╰──────────────╯       ╰──────────────╯│
  │                                                                 │
  └─────────────────────────────────────────────────────────────────┘

Key Concepts

Claude Code Integration

Install Animus Skills for deep Animus integration inside Claude Code:

git clone https://github.com/samishukri/animus-skills.git ~/animus-skills
claude --plugin-dir ~/animus-skills

CLI

animus task          Create, list, update, prioritize tasks
animus workflow      Run and manage multi-phase workflows
animus daemon        Start/stop the autonomous scheduler (v0.3.0: event-driven)
animus queue         Inspect and manage the dispatch queue
animus agent         Control agent runner processes
animus output        Stream and inspect agent output
animus doctor        Health checks, auto-remediation, and troubleshooting (v0.3.0+)
animus cloud         Sync state, manage webhooks, and access cloud dashboard (v0.3.0+)
animus init          Initialize a project from a bundled or local template
animus setup         Lower-level bootstrap and configuration wizard
animus requirements  Manage product requirements
animus mcp           Start Animus as an MCP server
animus web           Launch the embedded web dashboard
animus status        Project overview at a glance

Architecture

Animus is a Rust-only workspace with 17 crates. The major crates are:

• orchestrator-cli - CLI commands and dispatch
• orchestrator-core - services, state, and workflow lifecycle
• orchestrator-config - workflow YAML scaffolding, loading, and compilation
• workflow-runner-v2 - workflow execution runtime
• agent-runner - LLM CLI process management
• llm-cli-wrapper - CLI tool abstraction layer
• orchestrator-daemon-runtime - daemon scheduler, cron, event triggers (v0.3.0+)
• orchestrator-providers - provider integrations (cloud sync, webhooks, auth)
• orchestrator-notifications - event streaming and cloud syncing (v0.3.0+)
• orchestrator-logging - shared logging utilities
• orchestrator-web-server - embedded React dashboard
• orchestrator-web-api - web API business logic
• orchestrator-store - persistence primitives
• protocol - shared types and routing

graph LR
    A[CLI] --> B[Core Services]
    A --> C[Daemon Runtime]
    B --> D[Workflow Runner]
    D --> E[Agent Runner]
    E --> F[LLM CLI Wrapper]
    F --> G[claude / codex / gemini]
    B --> H[Config]
    H --> I[YAML Compiler]
    A --> J[Web Server]
    J --> K[Web API]
    K --> B
    C --> D
    style A fill:#1f6feb,stroke:#1f6feb,color:#fff
    style C fill:#1f6feb,stroke:#1f6feb,color:#fff
    style J fill:#1f6feb,stroke:#1f6feb,color:#fff

Platforms

License

This project is licensed under the Elastic License 2.0 (ELv2). You may use, modify, and distribute the software, but you may not provide it to third parties as a hosted or managed service.

curl -fsSL https://raw.githubusercontent.com/launchapp-dev/ao/main/install.sh | bash

rm -f ~/.local/bin/animus \
  ~/.local/bin/agent-runner \
  ~/.local/bin/llm-cli-wrapper \
  ~/.local/bin/animus-oai-runner \
  ~/.local/bin/animus-workflow-runner