"I was spending so many hours chasing ideas — I wanted to build SaaS templates, an auth platform, an ecommerce CRM, every direction I could think of. Animus is what made that possible. At one point I had 16 projects with 80 agents running in parallel doing real work. This is what I always wished existed."

— Sami, building LaunchApp

Open a fresh Claude Code (or Codex / OpenCode / Cursor) session and paste this. The agent installs the Animus CLI, clones animus-skills, runs the setup script, and adds the project section to CLAUDE.md / AGENTS.md. You'll be running workflows in about a minute.

Install Animus + Animus Skills: run curl -fsSL https://raw.githubusercontent.com/launchapp-dev/animus-cli/main/scripts/install.sh | bash to install the animus CLI (currently v0.5.15 in this repo), then animus plugin install-defaults to pull in the provider + subject + workflow_runner + queue plugins the daemon needs (one-time setup, idempotent; add --include-recommended for the web UI and extra providers). Then git clone --single-branch --depth 1 https://github.com/launchapp-dev/animus-skills.git ~/.claude/skills/animus-skills && cd ~/.claude/skills/animus-skills && ./setup to link the skills and write .mcp.json. Add an "Animus" section to CLAUDE.md (or AGENTS.md for Codex) listing the slash commands: /animus-setup, /animus-getting-started, /animus-mcp-setup, /animus-workflow-authoring, /animus-pack-authoring, /animus-skill-authoring, /animus-troubleshooting. Restart the agent so the new animus MCP server is picked up. From a project root, run animus init --walkthrough to scaffold .animus/, install packs, and optionally start the daemon.

For Codex CLI, swap the clone path to ~/.codex/skills/animus-skills and edit AGENTS.md instead of CLAUDE.md.

curl -fsSL https://raw.githubusercontent.com/launchapp-dev/animus-cli/main/scripts/install.sh | bash
animus plugin install-defaults

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

The second command is required in v0.4.12 and later (and expanded in v0.5 to include workflow_runner and queue plugins) — the daemon no longer ships with bundled providers, subject backends, workflow runners, or queue implementations. It will refuse to start until at least one of each required role is installed. The command is idempotent and skips anything already installed. Pass --include-recommended to also get the web UI, GraphQL transport, and additional providers.

# Specific version
ANIMUS_VERSION=v0.5.15 curl -fsSL https://raw.githubusercontent.com/launchapp-dev/animus-cli/main/scripts/install.sh | bash
# Custom directory
ANIMUS_INSTALL_DIR=/usr/local/bin curl -fsSL https://raw.githubusercontent.com/launchapp-dev/animus-cli/main/scripts/install.sh | bash
# Run install-defaults automatically as the last step
ANIMUS_INSTALL_PLUGINS=1 curl -fsSL https://raw.githubusercontent.com/launchapp-dev/animus-cli/main/scripts/install.sh | bash
# Skip the post-install plugin step (CI / Docker)
ANIMUS_SKIP_PLUGIN_INSTALL=1 curl -fsSL https://raw.githubusercontent.com/launchapp-dev/animus-cli/main/scripts/install.sh | bash

animus daemon stop
curl -fsSL https://raw.githubusercontent.com/launchapp-dev/animus-cli/main/scripts/install.sh | bash
animus plugin install-defaults --include-subjects --include-transports
animus daemon preflight # verify all required plugins present
animus daemon start

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

Animus is how one founder ships a portfolio of products.

Define your agent team in YAML. Animus runs them in parallel git worktrees, gates their work through quality checks, and opens reviewed PRs — while you focus on the next idea.

Use Claude, Codex, Gemini, OpenCode, Ollama, or any coding agent you already use. Animus orchestrates — it doesn't replace your tools.

• Local-first. Your code never leaves your machine.
• Plugin-first. Works with Linear, GitHub Issues, Asana, Jira, or whatever tracker you already use.

The core daemon is the orchestration runtime; providers, subject backends, triggers, transports, web UI, and log storage ship as independent animus-* plugins under launchapp-dev. animus plugin install <owner/repo> pulls them in with optional cosign signature verification. The daemon discovers installed plugins at startup, exposes a Unix-socket control protocol, and the CLI, MCP server, and web transports route through that control surface.

 ┌──────────────────────────────────────────────────┐
 │ 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) │
 └──────────────────────────────────────────────────┘

Today: portfolio builders.

• Solo founders running 3+ projects in parallel
• Indie hackers shipping every idea they have
• Two-founder studios trying to ship like a 20-person team

Increasingly: teams drowning in code maintenance.

• Codebases with stale deps, missing tests, and doc drift
• Microservices nobody has time to maintain
• Legacy systems waiting for "the modernization project"

Not for:

• Anyone looking for AI to "replace" their engineers
• Enterprise looking for a managed coding agent (the Devin / Codespaces use case)
• Teams already happy doing everything inside Cursor or Claude Code

The same capabilities — parallel worktrees, supervised agents, quality gates, automated PRs — serve both audiences. We started with portfolio builders because that's the user we know best: we are one.

cd your-project # any git repo
animus init --walkthrough # guided setup: plugins, packs, starter workflow, daemon

The walkthrough installs required plugins, installs recommended workflow packs, copies a starter workflow into .animus/workflows/, and optionally starts the daemon. It is the fastest path from zero to running workflows. Scripted / CI alternative:

animus doctor # check prerequisites and auto-remediate
animus plugin install-defaults # one command: provider + subjects + workflow_runner + queue
animus init --template task-queue --non-interactive --install-packs
animus daemon preflight # verify all required plugins are present
# Option 1: run a workflow on demand
animus subject create --kind task --title "Add rate limiting" --priority p1
animus workflow run --task-id TASK-001
# Option 2: go fully autonomous
animus daemon start # daemon executes ready subjects continuously
animus daemon health # verify it's up
animus logs tail --limit 100 # inspect recent daemon events
animus daemon stream # live structured event stream
# Scaffold a brand-new subject backend (Jira, Notion, anything with an API):
animus plugin new --kind subject --name jira

v0.5 note: the daemon will refuse to start unless plugins for all required roles are installed — provider, subject backend, workflow_runner, and queue. Run animus daemon preflight for the exact remediation command if startup fails. See docs/migration/v0.4.11-to-v0.4.12.md for the upgrade story from v0.4.11; v0.5 follows the same install-defaults remediation pattern.

Bundled init templates: task-queue, conductor, direct-workflow.

v0.4.4 note: animus task ... and animus requirements ... were removed in favor of animus subject --kind <kind>. Install the task and requirement subject plugins, then route through subject --kind task or subject --kind requirement.

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
 type: github_webhook
 workflow_ref: pr-reviewer
 enabled: true
 config:
 events: ["pull_request"]

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 ││
 │ ╰──────────────╯ ╰──────────────╯ ╰──────────────╯│
 │ │
 └─────────────────────────────────────────────────────────────────┘

The plugin ecosystem lives in standalone GitHub repositories under launchapp-dev. The exact (repo, tag) set installed by animus plugin install-defaults lives in a single source of truth at crates/orchestrator-core/src/plugin_registry.rs so the CLI installer and the daemon preflight always agree on which tag is "the default":

animus plugin install launchapp-dev/animus-provider-claude
animus plugin list # see what's installed with SIG column
animus plugin install-defaults --include-subjects --include-transports
animus plugin new my-thing --kind subject # scaffold from the template

Installs verify a sigstore cosign signature when one is published. Use --require-signature to enforce. See docs/architecture/plugin-signing.md.

Animus Skills is the companion skill bundle. Install with the one-paste prompt above, or directly:

git clone https://github.com/launchapp-dev/animus-skills.git ~/animus-skills
cd ~/animus-skills && ./setup # auto-detects installed agent hosts

The ./setup script supports --host claude|codex|opencode|cursor|slate|kiro|all, --no-cli (skip animus install), and --no-mcp (skip writing project .mcp.json).

animus subject Unified subject surface: list/get/create/update/next/status --kind <kind>
 (kind=task and kind=requirement are served by installed subject_backend plugins)
animus workflow Run and manage multi-phase workflows
animus daemon Start/stop the autonomous scheduler (start, stop, health, stream)
animus queue Inspect and manage the dispatch queue
animus agent Control agent runner processes
animus output Stream and inspect agent output
animus logs Tail daemon events.jsonl or whichever log-storage plugin is active
animus trigger Manage event triggers (file_watcher, webhook, github_webhook, slack)
animus pack Install, list, and update workflow packs
animus plugin Install, list, inspect, and scaffold stdio plugins
animus skill Install and inspect Animus skills
animus git Worktree and branch helpers
animus history Inspect run history (includes phase + runtime error reports)
animus init Initialize a project from a template registry or local template
animus mcp Start Animus as an MCP server
animus web Launch installed web dashboard/transport plugins
animus status Project overview at a glance
animus approval Manage approvals for destructive operations
animus auth Inspect identity and permissions
animus events Stream workflow lifecycle events
animus state Export and import scoped runtime state
animus secret Manage project-scoped secrets in the OS keychain
animus doctor Health checks, auto-remediation, and troubleshooting

Run animus --help for the full surface.

Removed in v0.4.4: animus task (→ animus subject --kind task), animus requirements (→ animus subject --kind requirement), animus setup (→ animus init), animus now (→ animus status), animus errors (→ animus history).

Animus v0.5 is a kernel + flavors architecture: a Rust workspace daemon kernel plus a curated bundle of out-of-tree plugins for providers, subject backends, workflow execution, queues, transports, and web UI. The current workspace members from Cargo.toml are:

• animus-plugin-protocol — in-tree stdio plugin protocol types
• animus-plugin-runtime — runtime helpers for plugin implementations
• protocol — shared protocol, config, repository-scope, and CLI JSON envelope types
• orchestrator-daemon-runtime — daemon queue, scheduling, subject dispatch, and runtime supervision
• orchestrator-logging — shared tracing and log-file utilities
• orchestrator-plugin-host — plugin discovery, install state, stdio host, and provider session bridge
• orchestrator-config — workflow YAML loading, pack loading, scaffolding, and phase plan resolution
• orchestrator-core — domain services, bootstrap, plugin registry, and state mutation APIs
• orchestrator-cli — main animus binary, clap surface, MCP server, and CLI operations
• animus-runtime-shared — shared workflow execution and runtime-contract helpers used by the daemon and external workflow_runner plugins
• animus-mcp-oauth — OAuth authorization-code + PKCE helpers and the animus-mcp-proxy bridge for protected MCP servers

Provider execution and the web stack are no longer in-tree crates. The OpenAI-compatible runner ships as the external launchapp-dev/animus-provider-oai-agent plugin, and animus web resolves external transport/UI plugins rather than an embedded web server.

v0.5 reference plugins (install via animus plugin install-defaults):

• animus-workflow-runner-default v0.4.1 — Rust workflow_runner plugin
• animus-queue-default v0.2.0 — Rust queue plugin with atomic queue/lease + queue/release_pending
• animus-step-durable-dbos v0.2.0 — Postgres + DBOS-backed durable_store
• animus-memory-zep v0.1.0 — Zep Cloud memory_store

See docs/architecture/full-system-architecture.md, docs/architecture/runtime-architecture.md, and docs/architecture/plugin-system.md for the current source-backed architecture docs.

The web dashboard is no longer bundled in-tree. Install it as plugins via animus plugin install-defaults --include-transports (animus-transport-http + animus-transport-graphql + animus-web-ui).

graph LR
 A[CLI] --> B[Core Services]
 A --> C[Daemon Runtime]
 B --> D[Workflow Runner]
 D --> E[Agent Runner]
 E --> F[Session Host]
 F --> G[Provider Plugins]
 B --> H[Config Compiler]
 A --> I[Plugin Host]
 C --> I
 I --> J[Subject / Trigger / Transport Plugins]
 C --> D
 style A fill:#1f6feb,stroke:#1f6feb,color:#fff
 style C fill:#1f6feb,stroke:#1f6feb,color:#fff
 style I fill:#1f6feb,stroke:#1f6feb,color:#fff

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/animus-cli/main/scripts/install.sh | bash

rm -f ~/.local/bin/animus \
 ~/.local/bin/ao

footer