Anima — Summary

Anima is a native macOS desktop application that replaces the terminal as the primary interface for Claude Code, adding per-project ASCII companion creatures ("familiars"), a cross-session Rust watcher daemon, nim token economy, voice input, and full-model oracle commentary.

Problem it solves: Claude Code's built-in /buddy ASCII creature operates with a small model, 5,000-character window, and single-session scope; Anima replaces it with a cross-session Rust daemon that monitors all active sessions simultaneously, fires observations through the full Claude model, and renders selectable commentary text.

Distinctive trait: The gamified "nim" token economy — 1 nim per 1,000 tokens spent — enables re-rolling for new companion species and rarity. Each project always generates the same familiar (deterministic from project path); developers on the same codebase get different creatures. This makes the companion a project identity artifact, not just a UI widget.

Tech stack: Tauri v2 + Rust backend (async Tokio daemon) + vanilla JavaScript frontend (no framework, no bundler). Binary is 4 MB. Requires Claude Code CLI, Node.js 20, Rust, and Git LFS (for bundled voice sidecar binaries).

Target audience: Solo developers on macOS who want a more engaging, cross-session aware Claude Code experience with voice input and gamified token awareness. Alpha-stage, solo project.

Production-readiness: 15 stars, MIT license, 1 contributor; v0.1.0-alpha; pushed April 2026. No signed DMG published — build from source only.

differs_from_seeds: Anima is a Claude Code subprocess manager with gamification layer — not a methodology or skill pack. Unlike all 11 seeds which shape agent behavior, Anima wraps the agent in a companion experience. The closest conceptual cousin is opcode (visual management layer) but Anima is far more focused on the live emotional/gamified experience rather than session analytics.

Anima — Overview

Origin

Solo project by Bradley Tangonan (btangonan), described as "alpha software" with explicit warning: "Breaking changes happen." Built on Tauri v2 with vanilla JavaScript frontend and Rust backend.

Philosophy

Anima's design philosophy centers on presence and engagement rather than workflow discipline. Where other Claude Code companions add productivity features (session analytics, cost tracking, checkpoint diffs), Anima adds emotional resonance through a character layer:

"Anima turns your Claude buddy into an oracle. A cross-session code supervisor running the full Claude model, inside a native macOS app."

The comparison to Claude Code's built-in /buddy is explicit:

"Claude Code ships with a basic buddy. An ASCII creature that hatches in your terminal, watches you work, and occasionally drops a line in a speech bubble. It's charming. It's also limited: the buddy can't see across sessions, can't remember what happened last time, its commentary comes from a small model working with a 5,000-character window, and the speech bubble text can't be copied or pasted back into your session."

Anima's answers to each limitation:

• Cross-session: Rust daemon monitors all active sessions simultaneously
• Memory: Per-project companion retains identity and nim balance across sessions
• Model quality: Oracle commentary uses full Claude model (not the small buddy model)
• Copyable: Speech bubble text is selectable and pastable into sessions

Token economy design

The nim currency mechanic is the most unusual feature in the batch. Key design choices:

• 1 nim = 1,000 tokens (automatically accrued)
• Spend nim to re-roll companion species, rarity, and personality
• Same project always generates the same base familiar (deterministic from project path)
• Two developers on the same codebase get different creatures (possibly from user-specific seeding)

This turns token usage — usually experienced as cost anxiety — into a reward mechanic.

Technical ambition vs. reality

Anima's README is candid about limitations: voice STT/TTS defaults off because the bundled anima-stt sidecar is missing a dependency (mlx_whisper). Users who want live voice today must provide an external WebSocket STT bridge at ws://127.0.0.1:9876. The .mcp.json file suggests MCP integration exists but is undocumented.

Anima — Architecture

Distribution

Build from source only (alpha; no signed DMG).

git clone https://github.com/btangonan/anima
git lfs install && git lfs pull   # voice binaries are LFS-tracked
nvm use                            # Node 20 (pinned by .nvmrc)
npm install
npm run tauri dev                  # dev build
npm run tauri build                # prod build (unsigned)

Note: Node 22+ is explicitly unsupported due to vitest #8757.

Directory structure

anima/
├── src/                           # Vanilla JavaScript frontend
│   ├── app.js                     # Main app initialization
│   ├── session.js                 # Session management
│   ├── session-lifecycle.js       # Start/stop/resume
│   ├── companion.js               # Familiar rendering + state
│   ├── nim.js                     # Token economy logic
│   ├── cards.js                   # Stat card generation
│   ├── ascii-sprites.js           # ASCII creature sprites
│   ├── history.js                 # Session history replay
│   ├── voice.js                   # Voice input (WebSocket)
│   ├── messages.js                # Message rendering
│   ├── hook-events.js             # Claude Code hook events
│   ├── slash-menu.js              # Slash command menu
│   ├── tts-player.js              # Text-to-speech player
│   └── ...
├── src-tauri/                     # Rust backend
│   ├── src/
│   │   ├── main.rs                # Tauri builder
│   │   ├── lib.rs                 # Core exports
│   │   ├── bin/                   # Sidecar binaries
│   │   ├── commands/              # Tauri IPC commands
│   │   ├── mcp_gate/              # MCP integration
│   │   ├── models_manifest.rs     # Model list
│   │   ├── voice_protocol.rs      # Voice WebSocket protocol
│   │   └── ws_bridge.rs           # WebSocket bridge for voice
├── sprites/                       # ASCII creature sprites
├── .mcp.json                      # MCP server config
├── .nvmrc                         # Node 20 pin
└── docs/
    └── architecture.md            # Architecture notes

Data flow

1. Anima spawns Claude Code as a subprocess (not just watching files)
2. Pipes stream-json from Claude Code subprocess to frontend
3. Rust daemon (daemon.rs / Tokio async) polls session feeds across all active sessions
4. When daemon detects retry loops or read-heavy spirals, emits Tauri events
5. Frontend triggers oracle commentary: claude -p subprocess with companion personality context
6. Oracle output rendered in companion speech bubble (selectable text)
7. Token usage increments nim balance (1 nim per 1,000 tokens)

Voice architecture

WebSocket bridge at ws://127.0.0.1:9876:

• Bundled anima-stt sidecar (disabled by default, requires mlx_whisper)
• External STT bridge (any compatible WebSocket server)
• Push-to-talk via Bluetooth mic

Requirements

• macOS 13 Ventura+ (Apple Silicon only)
• Claude Code CLI authenticated
• Node.js 20 LTS
• Rust toolchain + Xcode CLT
• Git LFS (for bundled voice sidecar)

Anima — Components

Anima ships no Claude Code primitives (commands, skills, hooks). Components are frontend JS modules and Rust backend modules.

Frontend JavaScript modules

Rust backend modules

Companion system (key feature)

• Species: Weighted rarity pool for ASCII creature generation
• Determinism: Same project path always generates same base familiar
• Nim economy: Accrual rate = tokens_spent / 1000; spend on re-rolls
• Oracle: claude -p subprocess with personality context (species + stats injected); max 2 concurrent calls; all local API calls

MCP integration

.mcp.json file exists in repository root indicating MCP server configuration, but documentation for this integration is sparse in the alpha README.

Anima — Uniqueness & Positioning

differs_from_seeds

Anima is unlike all 11 seeds — it is a gamified companion experience, not a methodology framework:

• vs. all skill-based seeds: Those inject prompting discipline. Anima injects personality and gamification.
• vs. ccmemory (MCP-toolserver): ccmemory adds persistent knowledge. Anima adds companion character and cross-session awareness.
• vs. opcode (batch companion): opcode provides analytics + agent management. Anima provides emotional engagement + gamification.
• vs. poirot (batch companion): Poirot reads past sessions. Anima monitors live sessions and talks back.

Most distinctive feature in the entire corpus

The nim token economy is unique in the entire Phase D corpus — no other framework converts token spend into in-game currency or attaches gamification mechanics to AI development. This is a novel approach to making cost visible without triggering anxiety (reward framing vs. cost framing).

Positioning within the batch

Within the 10 batch frameworks, Anima occupies a "alive companion" niche that none of the others attempt:

• opcode: analytics dashboard
• Poirot: forensics viewer
• Agent FM: ambient narration radio
• Anima: interactive companion with its own character, economy, and memory

Observable failure modes

1. Alpha stability: Sole maintainer, 15 stars, "alpha software" self-described. Breaking changes are expected.
2. Voice is broken by default: The STT sidecar is disabled; users wanting the headline voice feature must build their own WebSocket bridge.
3. Apple Silicon only: Explicitly limited to arm64 macOS; no x86 or Linux.
4. Git LFS dependency: The voice sidecar binaries are tracked in Git LFS; clones without LFS support will be missing these.
5. Gamification fatigue risk: Token economy and companion re-rolls are charming but may feel trivial to professional developers who find the overhead doesn't match the utility.
6. Oracle cost: Background claude -p calls for oracle commentary consume API tokens beyond the main session. For users on token budgets, the companion adds measurable cost.
7. Node 22+ incompatible: Pinned to Node 20 due to vitest compatibility issue; creates developer friction.