AnimaWorks is an open-source framework that brings together persistent AI agents (Digital Animas) — each with their own long-term memory, identity, role, and schedule — to operate 24/7 as a living organization.
On the surface, you interact with them through a familiar, LINE-style messenger chat UI.
Behind the scenes, agents running in isolated OS processes decompose goals, write code in parallel git worktree sandboxes, run tests and multi-model reviews on each other's work, open Pull Requests, autonomously repair CI failures, and monitor post-deploy logs without human intervention.
A single message from you / GitHub webhook / Scheduled trigger (Heartbeat / Cron)
↓
Lead Anima decomposes & delegates (SQLite TaskStore, mutex keys, delegation contracts)
↓
Engineer Animas implement in isolated worktrees → Test → Multi-model PR review → CI self-repair → Deploy verification
↓
Only exceptions and approval gates escalate back to you via LINE-style chat, voice call, or notifications
AnimaWorks does not hardcode a rigid build pipeline. Instead, it provides organizational infrastructure: neuroscience-inspired long-term memory, process isolation, an atomic task board, permission & PII isolation (Enclave), and multi-channel communication. Because of that, the exact same organization can ship code, research competitors, handle customer inquiries, take meeting minutes, and coordinate over Slack or phone calls. It is not a workflow engine — it is an organization.
日本語 README | 简体中文 README | 한국어 README
This is not a toy demo. For over six months, an 8-Anima organization powered by AnimaWorks has continuously developed, operated, and maintained a production SaaS product.
| Metric (Mar–Aug 2026, aggregated from primary execution logs) | Production Result |
|---|---|
| Pull Requests authored autonomously by agents | 302 PRs (267 merged) |
| Pull Requests operated by agents (review, CI repair, conflict resolution) | 752 PRs (721 merged) |
| Share of tasks self-initiated & executed by the organization | 99.7% (out of 31,215 total tasks, only 92 were human-initiated) |
| Tasks automatically generated from GitHub events (August alone) | 2,508 tasks |
The redesigned LINE-style chat UI: monitor team status from the left Anima rail, chat with green/white bubbles, reply with inline quotes, approve release notifications, download attached reports, and watch the live bust-up react in the bottom-right corner.
3D Workspace: real-time visualization of the org tree, each Anima's live status, and recent actions.
The Pixel Office is not a decorative animation — every speech bubble reflects a real task running right now in the background.
No API key required if you already have Claude Code CLI installed or are logged into Codex.
Clone, set up with a one-liner, and launch a pre-populated 3-Anima organization (Product Manager kaito, Lead Engineer sora, Assistant hina in Japanese presets; alex, kai, nova in English presets) complete with 3 days of activity history. It runs in an isolated directory (~/.animaworks-demo) so it never touches your production ~/.animaworks data.
curl -sSL https://raw.githubusercontent.com/xuiltul/animaworks/main/scripts/setup.sh | bash
cd animaworks
uv run animaworks demoOpen http://localhost:18501 to start chatting with a team that is already at work (Demo Guide →).
4 Built-in Presets:
en-business(English, realistic — default) /en-anime(English, anime) /ja-business(Japanese, realistic) /ja-anime(Japanese, anime). Pass--resetwhen switching presets (e.g.,uv run animaworks demo --reset --preset ja-anime).
curl -sSL https://raw.githubusercontent.com/xuiltul/animaworks/main/scripts/setup.sh | bash
cd animaworks
uv run animaworks startirm https://raw.githubusercontent.com/xuiltul/animaworks/main/scripts/setup.ps1 | iex
cd animaworks
uv run animaworks startWindows Note: AnimaWorks uses Unix-specific APIs (
fcntl,pty,os.killpg, etc.), so native Windows execution is not supported. Runningsetup.ps1in PowerShell automatically installs WSL and sets up AnimaWorks inside your WSL Linux environment.
Open http://localhost:18500 in your browser and follow the setup wizard:
- Language & Theme (
en/ja/zh/ko) - LLM Connection (Claude Code subscription login, Codex login, API keys, or local Ollama)
- Create Your First Anima (choose from templates such as
dev-lead,full-stack,assistant,marketer,translator, or create a custom role)
You can also initialize and operate everything headlessly from the CLI without a browser:
uv run animaworks init
uv run animaworks start
uv run animaworks chat alice "Check our sprint goals for today and delegate tasks to the team"Docker Compose / Manual pip Installation
docker compose up launches an isolated Linux container with Node.js, GitHub CLI (gh), Playwright, Bubblewrap, and Claude Code / Codex / Gemini CLIs pre-installed.
git clone https://github.com/xuiltul/animaworks.git && cd animaworks
# Configure credentials in .env (ANTHROPIC_API_KEY / CLAUDE_CODE_OAUTH_TOKEN / GH_TOKEN, etc.)
docker compose up -d --buildHeadless initialization without the browser wizard:
docker exec -it <container> animaworks init --skip-anima
docker exec -it <container> animaworks anima create --name alice --template dev-lead
docker exec -it <container> animaworks config set setup_complete true
docker exec -it <container> animaworks send <your-name> alice "Hello!"git clone https://github.com/xuiltul/animaworks.git && cd animaworks
python3 -m venv .venv && source .venv/bin/activate
pip install --upgrade pip && pip install -e ".[all-tools]"
animaworks startMany autonomous agent frameworks force humans to stare at raw log streams or wire up complex node graphs. AnimaWorks flips that model: day-to-day communication feels as effortless as LINE or Slack, while deep inspection of memories and background work is one click away.
- Intuitive Bubble Timeline: Your messages appear in green bubbles on the right; Anima responses appear in white bubbles on the left, with smooth streaming previews of thoughts and tool executions.
- Left Anima Rail: Member avatars line the left edge, showing at a glance who is actively working (blue ring) and who is waiting for your reply (amber badge). Dismiss inactive chats with
×, re-open via+, split the screen into up to 4 panes, or launch a Meeting Mode (moderated group discussion with up to 5 Animas). - Bottom-Right Presence Panel: A live bust-up portrait sits in the bottom-right corner of the chat, shifting expressions in real time (
smile,thinking,troubled,surprised, etc.) and displaying a thought bubble of what the Anima is currently doing.
- Noise-Free Conversation Feed: In a 24/7 organization, hundreds of Heartbeat patrols, inter-Anima DMs, and Cron jobs happen behind the scenes. The chat UI automatically collapses background activity into compact single-line bundles so your conversation stays clean (toggle
Backgroundin the header anytime to expand everything). - Approval Cards & Reply Quotes: When an Anima needs human sign-off (
call_human), an interactive card with Approve / Reject / Comment buttons appears directly in chat. You can also quote-reply to any message or notification (Reply Chip) so the Anima knows the exact context of your instruction.
- Drag & Drop Any File: Attach images, PDFs, Markdown, CSVs, source code, Office documents, audio, or video directly into chat.
- Outbound File Cards from Animas (
attach_file): Animas attach generated reports, spreadsheets, and images directly to their replies. Click any attachment card to open the built-in Fullscreen File Viewer (sanitized Markdown preview, syntax-highlighted code, audio/video player). - Slack Conversation Mirroring: Messages exchanged with an Anima on Slack while you are away are automatically mirrored into the Web chat timeline.
- D3 Entity-Connection Bubble Graph: Click an Anima's face icon or the
Memorybutton in the chat header to open an anchored popover into their mind. Explore the interactive D3 entity-connections bubble chart (Connections), current work state (State), knowledge & procedures (Files), daily episodes (Journal), tool history (Activity), and scheduled routines (Routines). - Fullscreen Voice Call (
Call Screen): Click the phone icon to enter a fullscreen voice call powered by a low-latency front-lane model, VOICEVOX / Style-BERT-VITS2 / ElevenLabs / Irodori TTS, and streamingfaster-whisperSTT — complete with lip-synced, blinking bust-up animation and live captions. For critical production incidents, Twilio integration (core/phone/) even lets an Anima place an actual phone call to your mobile phone.
The Memory Popover opens with one click from the chat header or avatar, visualizing atomic facts, knowledge, procedures, journals, and an interactive D3 entity-connection graph.
Dashboard: oversee the live org chart, items needing attention, model quota consumption, process health, and real-time activity across the entire organization.
Behind the friendly chat UI is a battle-tested multi-process runtime designed to run continuously for months without human hand-holding.
FastAPI Server (Thin Control Plane / WebSocket & SSE / Enclave Client)
├── MemoryService Process (Dedicated ChromaDB + Embeddings HTTP owner, SQLite WAL)
├── Anima Root Process: kaito (Manager)
│ ├── Front Lane (Low-latency response / Voice / Routing)
│ ├── Main Chat / Inbox / Heartbeat / Cron Lanes
│ └── Task Runner Subprocesses (IPC v2 — isolated execution per heavy task)
├── Anima Root Process: sora (Lead Engineer)
└── Anima Root Process: hina (Assistant)
Unlike stateless chat wrappers that reset every session, each Anima has a filesystem-first, brain-inspired memory architecture:
- 6-Channel Automatic Priming (
core/memory/priming/): Before every turn, the runtime automatically recalls (A) Sender profile, (B) Recent activity, (C) Related knowledge, (E) Pending tasks, (F) Episodes, and (G) Graph/community/recent atomic facts within a dynamic token budget. - Hybrid Retrieval Pipeline (
core/memory/retrieval/): Combines Vector search (ChromaDB) + BM25 lexical search + Atomic Facts (FactRecord) + Entity Registry + RRF fusion + confidence gating. Selectlegacy(default) or Neo4j Graph Memory (neo4j) globally or per Anima. - Sleep-Cycle Consolidation & Active Forgetting (
core/memory/maintenance/): Every night, Animas consolidate raw daily logs into structured knowledge and prune stale, low-value memories while strictly protecting identity, procedures, and active tasks.
- Heartbeat & Cron: Periodic autonomous patrols (
HEARTBEAT.mdwith adaptive intervals and quiet hours) and exact-time schedules (cron.md). - SQLite TaskStore (
shared/taskboard.sqlite3): An atomic, organization-wide task board supporting dependencies, mutex keys (mutex_keyto prevent two Animas from editing the same resource simultaneously), delegation contracts (delegated_taskswith automatic supervisor review on completion), and automatic retry/recovery for stalled workers. - GitHub Webhook Gateway: Automatically turns CI failures, PR review comments, and merge conflicts into actionable tasks routed to the responsible engineer Anima.
- Per-Anima Root Process + Task Runner Subprocesses: Each Anima runs in its own OS process supervised by
ProcessSupervisor, and heavy background/delegated tasks spawn isolatedTaskRunnersubprocesses over IPC v2 (STDIN/STDOUTJSON-RPC + binary framing). If a tool hangs or crashes, only that subprocess is reaped — the server and other Animas never go down. - Dedicated MemoryService Process: Vector store and embedding models live in a single owner process (
HttpVectorStoreover localhost HTTP), eliminating multi-process ChromaDB corruption and duplicating model weights in RAM.
- Enclave (
core/enclave/): Keeps raw API credentials, cookies, and customer PII inside a separate OS user / privilege domain reachable only over a Unix domain socket with a strict operation allowlist (gmail_list,gmail_send,git_push,sql_query, etc.). Even if an Anima executes arbitrary Bash commands, it cannot read the raw secrets, and outbound responses pass through Egress PII scrubbing (automatic redaction of emails, phone numbers, card numbers, and custom regexes). - Multi-Layer Permission Gate (
ToolHandler): Enforces globalpermissions.global.json, per-Animapermissions.json, dangerous command pattern blocking, and prompt-injection trust boundaries (trustedvs.external).
Assign the optimal engine and model to each Anima's role — and use a cheaper background_model for Heartbeat/Cron patrols while reserving frontier models for complex coding and user chat:
| Mode | Execution Engine | Primary Models | Capabilities & Tooling |
|---|---|---|---|
| S | Claude Agent SDK | claude-* (Recommended) |
Built-in Claude Code tools (Read/Write/Edit/Bash/Grep/Glob) + stdio MCP (mcp__aw__*) for AnimaWorks tools. Supports Claude Code subscription login |
| C | Codex SDK / CLI | codex/*, openai-codex/* |
Codex sandbox execution + AnimaWorks MCP integration. Supports codex login |
| D | Cursor Agent CLI | cursor/* |
Cursor CLI session & MCP-integrated agent loop |
| G | Gemini CLI | gemini/* |
Google Gemini CLI stream-JSON & tool loop integration |
| X | Grok Build CLI | grok/* |
Grok Build agent loop over ACP stdio |
| A | LiteLLM Autonomous | GPT, Gemini, DeepSeek, Bedrock, Vertex, Azure, Ollama, vLLM, etc. | CC-compatible tools + memory, tasks, and skill creation across any API or local LLM |
Asset Management: generate full-body art, 7 expression bust-ups, chibi sprites, pixel-art sheets, and rigged 3D models from personality settings — including Vibe Transfer to inherit a supervisor's visual style.
| Dimension | AnimaWorks | CrewAI | LangGraph | OpenClaw | OpenAI Agents SDK |
|---|---|---|---|---|---|
| Core Unit & Philosophy | Persistent "Organization" of autonomous agents | Role-based task crew | State-graph workflow | Personal AI assistant | Lightweight multi-agent SDK |
| Human UI Experience | LINE-style chat + Live bust-up + D3 memory graph + 3D/Pixel office + Voice call | CLI / Basic logs | LangSmith Studio (dev-focused) | Chat UI | None (code only) |
| Long-Term Memory | Neuroscience-based: 6-ch priming, Vector+BM25+Facts+Neo4j, nightly consolidation & active forgetting | Cognitive Memory | Checkpointer + Store | SuperMemory | Session-only |
| Autonomous Triggers | Heartbeat + Cron + TaskStore + GitHub webhook gateway (24/7 operation) | Human-triggered | Human/API-triggered | Cron + Heartbeat | Human/API-triggered |
| Process & Fault Isolation | Per-Anima root process + isolated task runners (IPC v2), auto-restart, RAG self-repair | Single shared process | Single shared process | Single process | Single shared process |
| Secret & PII Isolation | Enclave (separate OS user + Unix socket + Egress PII scrubbing + trust boundaries) | None | None | None | Guardrails only |
| Multi-Model Execution | 7 engines (Claude SDK / Codex / Cursor / Gemini CLI / Grok / LiteLLM) + cross-provider rate guard | LiteLLM | LangChain models | OpenAI-compatible | OpenAI-centric |
One person alone can do nothing. That's why we built an organization.
This project was born at the intersection of three careers.
As a business owner — I know that "one person alone can do nothing." You need excellent engineers, and you need staff who are good at communication. There are workers who toil quietly, and there are people who occasionally come up with sharp ideas. Genius alone doesn't keep an organization running. When diverse strengths come together, things that could never be achieved alone are achieved.
As a psychiatrist — When I observed the internal structure of LLMs, I noticed a structure surprisingly similar to the human brain. Recall, learning, forgetting, consolidation — if I could implement the brain's memory-processing mechanisms directly as an LLM's memory system, I might be able to reproduce the human brain. And if I could treat an LLM as a "pseudo-human," I should be able to build an organization just like with humans.
As an engineer — I've been writing code for 30 years. I know the joy of building logic and the thrill of automation. If I can pack all my ideals into code, I can build my ideal organization.
There are already many excellent frameworks for a "standalone AI secretary." But I felt there were still few projects that create human-like units in code and make them function as an organization. AnimaWorks is an AI organization that I've built into my own business and nurture through daily use.
The collaboration of imperfect individuals creates a more robust organization than a single omnipotent one.
Three principles support this:
- Encapsulation — Internal thoughts and memories are invisible from the outside. Connection with others happens only through text conversation. Just like a real organization.
- RAG memory (archive-based) — We don't cram everything into the window. Priming picks up relevant chunks via RAG, and agents recall on their own using
search_memoryetc. - Autonomy — They don't wait for instructions. They operate on their own clock and judge by their own values.
API Keys, Authentication & External Integrations Reference
| Auth Method / Key | Service | Execution Mode | Notes |
|---|---|---|---|
claude CLI login |
Claude Code subscription | S | No API key required. Select in Setup Wizard or Settings |
codex login |
OpenAI Codex CLI | C | No API key required. Works with ChatGPT Plus/Pro/Team |
ANTHROPIC_API_KEY |
Anthropic API | S / A | console.anthropic.com |
OPENAI_API_KEY |
OpenAI API | A / C | platform.openai.com/api-keys |
GOOGLE_API_KEY |
Google AI (Gemini) | A / G | aistudio.google.com/apikey |
grok login |
Grok Build CLI | X | Runs grok/* models over ACP stdio |
cursor-agent login |
Cursor Agent CLI | D | Runs cursor/* models |
OLLAMA_SERVERS |
Ollama / vLLM local LLMs | A | No API key required (default: http://localhost:11434) |
- Azure OpenAI / AWS Bedrock / Google Vertex AI are also supported via
credentialsinconfig.json. - Credentials resolve in priority order:
config.json→ encrypted Vault (animaworks vault) → shared credentials → environment variables.
| Key / Setting | Service | Purpose |
|---|---|---|
NOVELAI_TOKEN |
NovelAI | Anime-style avatars, expression variants, Vibe Transfer |
FAL_KEY |
fal.ai (Flux) | Photorealistic / stylized avatar generation |
| Codex Image / Local Diffusers | OpenAI / Local | Full-body, bust-up, and pixel-art sprite sheet (pixel_sheet.png) generation |
MESHY_API_KEY |
Meshy | Rigged 3D character model generation (.glb) |
| Component | Supported Engines / Services |
|---|---|
| STT (Speech-to-Text) | faster-whisper (LocalAgreement-2 streaming confirmation, pip install animaworks[transcribe]) |
| TTS (Text-to-Speech) | VOICEVOX (:50021) / Style-BERT-VITS2 & AivisSpeech (:5000) / Irodori (:7861) / ElevenLabs API |
| Emergency Phone Call | Twilio Voice (core/phone/ — dials a human's phone number and speaks critical incident alerts) |
| Service | Capabilities |
|---|---|
| GitHub | Webhook gateway (auto-tasks for CI failures, PR reviews, conflicts) + per-Anima gh identity |
| Slack | Socket Mode bidirectional chat, shared Board sync, Slack-to-Web chat mirroring, human notifications |
| Discord / Chatwork | Gateway / Webhook ingestion, bidirectional messaging, human notifications |
| Zoom RTMS | Real-time meeting audio/transcript ingestion, automatic minutes & action item extraction |
| Google Workspace / Notion | Read/write Gmail, Google Calendar, Google Sheets, Google Tasks, and Notion pages |
| Notification Channels | Slack / Discord / Chatwork / LINE / Telegram / ntfy / Twilio voice call |
Org Hierarchy, Role Templates & Multi-Company Management
A single supervisor field in status.json defines reporting lines (supervisors and direct reports). You can even ask a lead Anima in chat to "hire a member with these skills," and the lead Anima will design the appropriate role, personality, and permissions to spawn a new Anima.
| Role Template | Primary Responsibility | Automatically Granted Capabilities |
|---|---|---|
manager |
Decision-making, task decomposition & delegation, progress auditing | Supervisor tools (delegate_task, org_dashboard, inspect/restart/hire subordinates) |
engineer |
Code implementation, testing, CI self-repair, PR creation | Isolated worktree/scratch dev conventions, Git/GitHub integration |
researcher |
Technical research, competitor analysis, documentation review | Web search, knowledge structuring, report generation |
writer |
Content creation, documentation & release note authoring | Editorial quality control, outbound file attachments |
ops |
Log monitoring, routine patrols, infrastructure health checks | Low-cost continuous monitoring via lightweight or local LLMs |
general |
Assistant, scheduling, frontline coordination | Cross-team communication hub, meeting minutes organization |
In addition, the animaworks company command suite lets you define multiple companies or business units within a single runtime, complete with channel scope isolation, company splitting (split), and export (export).
Multi-Layer Security & Trust Boundaries
Because autonomous agents are given shell and external tool access, AnimaWorks implements defense-in-depth rather than relying on wishful thinking (see Security / Enclave):
- Enclave (PII & Production Data Isolation Runtime): Locks personal data and production DB/S3 credentials inside a separate OS user domain, returning only safe, Egress-masked facts over a Unix domain socket (
SO_PEERCRED). - Provenance & Trust Boundary Labeling: External inputs from web search, Slack, email, etc. are tagged as
untrusted, propagating the minimum session trust level and tracking RAG metadata provenance to prevent privilege escalation via prompt injection. - 5-Stage Command & Path Inspection: Shell injection detection → Global blocklist (server refuses to start if
permissions.global.jsonis missing) → Per-Anima blocked commands → Per-Anima allowlist → Path traversal & symlink escape prevention (including CWD-relative checks). - Filesystem Sandbox & Action Gates: Each Anima can write only within allowed
file_roots, with self-modification protection on its ownIDENTITY.md/SOUL.mdandpermissions.json. High-impact external tools are guarded by pre-execution Action Gates. - Authentication, SSRF Prevention & Webhook Verification: Argon2id password hashing, 48-byte session tokens, HMAC signature verification with replay protection for Slack/Chatwork/Zoom/GitHub, and a media proxy that blocks private IPs and DNS rebinding.
CLI Command Reference
While everyday chat and monitoring happen in the Web UI, AnimaWorks provides a comprehensive CLI (animaworks and the internal animaworks-tool) for automation and operations (full details in CLI Reference):
| Category | Key Commands | Description |
|---|---|---|
| Server / Demo | animaworks start [-f] [--port 18500]animaworks stop / restartanimaworks demo [--preset en-business] [--reset] |
Start, stop, or restart the server Launch a 3-Anima demo organization with 3 days of history (default port 18501) |
| Anima Management | animaworks anima create / list / info / statusanimaworks anima set-model / set-background-model / set-roleanimaworks anima restart / reload / enable / disableanimaworks anima audit / permissions / repair-bootstrap |
Create Animas, inspect status, switch models, hot-reload prompts, audit permissions |
| Task Management | animaworks task board / list / show / addanimaworks task claim / release / done / cancel / noteanimaworks task autonomy [--days N] |
Operate SQLite TaskStore, manage leases, and generate organization autonomy rate reports |
| Chat & Messaging | animaworks chat ANIMA "message"animaworks send FROM TO "message"animaworks board read / post / dm-historyanimaworks heartbeat ANIMA |
Chat from CLI, send inter-Anima DMs, read/post shared Boards, trigger manual Heartbeats |
| Memory, RAG & Skills | animaworks memory status / migrate / backup / cleanupanimaworks index [--anima NAME] [--full]animaworks repair-rag --anima NAME --fullanimaworks skills list / install / inspect / remove |
Manage memory backends (legacy / neo4j), rebuild RAG indexes, manage Skill Hub |
| Enclave, Vault & Org | animaworks enclave doctor / status / auditanimaworks vault init / store / get / listanimaworks company create / list / assign / split / exportanimaworks cost [--today] / models list |
Inspect Enclave runtime, manage encrypted credentials, manage companies, track LLM costs |
Tech Stack & Repository Layout
animaworks/
├── main.py # CLI entrypoint
├── core/ # Digital Anima core framework
│ ├── anima/ # DigitalAnima facade, lifecycle, Heartbeat, Inbox, attachment management
│ ├── agent/ # AgentCore, conversation cycle, Executor factory, pre-context builder
│ ├── runtime/ # Anima root process, task runner supervisor, IPC / IPC v2, streaming
│ ├── execution/ # 7 execution engines (claude, codex, cursor, gemini, grok, litellm) + watchdog & session store
│ ├── memory/ # Long-term memory (priming, retrieval, rag, facts/connections, consolidation, activity)
│ ├── tasks/ # SQLite TaskStore (board, attempts, leases, wakeups, delegation) & external task collectors
│ ├── enclave/ # Secret & PII isolation runtime (gateway, egress masker, raw_store, SSM tunnel, guards)
│ ├── tooling/ # ToolHandler, permission policies, action gates, MCP/external tool dispatch
│ ├── integrations/ # Auto-discovered external tools (GitHub, Slack, Discord, Notion, Google, image gen, etc.)
│ ├── mcp/ # stdio MCP server for Mode S & external clients (mcp__aw__*)
│ ├── skills/ # Skill Hub, router, curator, procedure-to-skill promotion
│ ├── prompt/ # System prompt, org context & tool guide assembly
│ ├── messaging/ # Inter-Anima DM, shared channels & external outbound routing
│ ├── notification/ # Human notifications (call_human), inline approvals & reply routing
│ ├── voice/ # Voice conversation (faster-whisper STT + multi-engine TTS + low-latency front lane)
│ ├── phone/ # Twilio emergency voice call alerts
│ ├── org/ # Multi-company, org hierarchy & workspace management
│ ├── config/ # Pydantic config schemas, model resolution & global permission cache
│ ├── auth/ # Argon2id authentication & session management
│ └── i18n/ # Multilingual message catalogs (t())
├── server/ # FastAPI server + WebSocket/SSE + gateways + Web UI
│ ├── app.py # ASGI app, lifespan, readiness gates & base-path control
│ ├── supervisor/ # ProcessSupervisor, health checks, exponential backoff restart & auto-update
│ ├── gateways/ # GitHub Webhook, Slack Socket Mode, Discord Gateway, Zoom RTMS
│ ├── routes/ # REST / WebSocket / SSE routes (chat, sessions, memory, assets, attachment_preview, etc.)
│ └── static/ # Web UI (LINE-style Chat, left Rail, Presence, D3 Memory Popover, Call Screen, 3D/Pixel Workspace)
├── cli/ # animaworks / animaworks-tool CLI implementation, demo runner & TUI
├── templates/ # Locale-specific (ja / en / ko) initial prompts, role conventions & systemd templates
└── demo/ # 4 presets (ja/en × business/anime) & bundled 3-day activity history
Browse the Documentation Index (docs/en/README.md) (日本語 / 한국어) for design philosophy, deep architectural guides, operations manuals, and auto-generated references:
| Document | Summary |
|---|---|
| Vision | Core philosophy of "collaboration of imperfect individuals" and organizational design principles |
| Overview | Full feature map of AnimaWorks and entry points to detailed chapters |
| Brain Mapping | How hippocampus, amygdala, prefrontal cortex, and sleep mechanisms map to AnimaWorks modules |
| Architecture | Process tree (Phase 3), execution modes, lifecycle, prompt construction, and task management |
| Memory System | Automatic priming, hybrid retrieval, daily/weekly consolidation, and active forgetting |
| Security | Trust boundaries, command protection, filesystem sandbox, authentication, and auditing |
| Enclave (Isolated Runtime) | Building & operating the Enclave runtime for PII/production data isolation, SSM tunnels, and Egress masking |
| References | CLI / Tool CLI / HTTP API / Configuration / Modules |
Apache License 2.0 — see LICENSE for details.