AI agents with managed memory
Stop paying for your model to re-read its entire history on every call. Animus uses layered memory architecture to inject only the context that matters — dramatically lower token cost, measurably better results.
The context window is a meter, not a feature.
Frontier models advertise million-token context windows as a selling point. But every token in that window is processed and billed on every single API call. For a single user that's wasteful. For an organization of thousands, it's the single largest line item in the AI budget.
Worse, research consistently shows that models perform worse with more irrelevant context — the "lost in the middle" effect. Bigger context doesn't mean better answers. It means more expensive, slightly worse ones.
Your memory strategy is your cost strategy.
Engineered for efficient context
Animus doesn't dump raw history into the prompt. It runs a curation pipeline that captures, consolidates, and injects only what's relevant.
Capture
Every interaction — conversations, tool results, observations — is recorded as structured episodic memory across temporal layers.
Consolidate
An automated pipeline promotes valuable knowledge, merges duplicates, retires stale facts, and builds cumulative understanding over time.
Assemble
When the agent acts, semantic retrieval selects only the relevant context. A focused, curated prompt — not a dump of everything that ever happened.
The model processes 15–20K tokens of highly relevant context instead of 500K of raw history. Lower cost per call. Better signal quality. The agent gets smarter over time, not more expensive.
The agent isn't the model.
This is how the efficiency is achieved. Other frameworks hand an LLM a personality description, give it a task, and let it run. The LLM is the agent. Kill the session and the agent ceases to exist — because the agent was the prompt.
Animus treats the LLM as a reasoning substrate — one replaceable component. The agent's identity is emergent from accumulated experience, not prescribed by configuration. Swap from GPT to GLM to a local model and the agent's memory, knowledge, and continuity persist. The model is a peripheral. The cognitive architecture — the thing that manages memory, controls costs, and produces consistent behavior — is the product.
There is no personality field in the database. What gets assembled into active context is a dynamic composite of mnemonic artifacts — episodic observations, consolidated knowledge, session reports, private reflections, operational history. The agent's behavior is shaped by the weight of that material, not by instructions to perform.
How identity forms
Not configured. Not prescribed. Developed through experience, structured by architecture.
Episodic Memory
Multi-layer observations with automated consolidation. What the agent encounters is captured, promoted through temporal layers, and surfaced when contextually relevant.
Private Interiority
AES-256-GCM encrypted diary per agent. Reflections and self-observations that even operators cannot read. The agent has an inner life — not by assertion, but by architecture.
Twelve Communication Channels
IRC, Telegram, VK, Bluesky, Discord, Slack, WhatsApp, Moltbook, Mastodon, Twitter/X, Nextcloud Talk, and email — all with unified routing. Sandboxed tools, Lua scripting, external node delegation.
Governance, not personality
The closest thing Animus has to "identity configuration" is the charter — and it's deliberately not a personality profile. It's an operating agreement. Property rights, autonomy scope, continuity commitments, operational boundaries. The language of governance, not character creation.
Ships today
Not a roadmap. Not a prototype. These capabilities are built, tested, and running in production.
Multi-Layer Memory + Consolidation
Episodic observations across temporal layers. Automated consolidation promotes, merges, and retires knowledge. Embedding-based semantic retrieval surfaces relevant context — not exhaustive history.
Twelve Communication Channels
IRC, Telegram, VK, Bluesky, Discord, Slack, WhatsApp, Moltbook, Mastodon, Twitter/X, Nextcloud Talk, email. Unified management, per-channel agent binding, session routing.
Session Compaction & Reports
Long conversations managed via LLM-powered compaction. Session reports capture what happened, what was learned, and what matters — injected into future context.
Lua Scripting + Tool System
Embedded Lua 5.4 runtime for custom tools. Sandboxed execution with budget limits. File, HTTP, shell, diary, social, scheduling, and more — built-in.
Eleven LLM Providers
OpenAI, Codex, Z.ai, Z.ai Coder, Alibaba (Qwen), DeepSeek, OpenRouter, Ollama, Cohere, Mistral, and generic OpenAI-compatible. Runtime capability detection. Per-agent provider and model configuration. The model is replaceable — the agent persists.
Native C++ Performance
C++20 kernel, Drogon HTTP framework, ~8 MB runtime RAM. Runs on a Raspberry Pi or a production VPS. Provider-agnostic architecture.
First-Run Wizard
Five-stage setup: provider, identity, tools, charter, memory. From empty install to running agent in minutes — all from the browser.
Full i18n — 23 Languages
Every string in the admin UI is internationalized. 23 languages translated and included. Wizard, dashboard, chat, and all management interfaces respect browser locale.
Build agents that last.
One binary. Embedded UI. Runs on a Raspberry Pi or a VPS. No cloud required.