Production-grade integrator of the Quorum coordination protocol — with budget controls, quality gates, and checkpoint/resume.
Animus coordinates AI agents across complex workflows with the operational discipline of a manufacturing line. Every agent has a token budget. Every workflow has a cost ceiling. If a pipeline fails at step 4 of 6, it restarts at step 4, not step 1. Inspired by the Toyota Production System: make cost visible, make waste impossible to ignore.
The coordination protocol underneath — Quorum — is published as an open specification with a reference implementation on PyPI. The proprietary orchestration, memory, and identity layers (Forge / Core / Bootstrap) are private.
Animus is intentionally split between open standards + reference implementation and private production-grade integrator.
| Layer | Status | Where to find it |
|---|---|---|
| Quorum Protocol Specification | Open (MIT, v0.1 draft) | quorum-protocol-spec-v0.1.md |
| Quorum reference implementation (Python) | Open (MIT) | convergentAI on PyPI · Standalone repo extraction pending |
| Forge — orchestration engine | Private (commercial optionality) | This docs repo describes it; source is not public |
| Core — exocortex (identity, memory, voice, integrations) | Private (personal sovereignty layer) | This docs repo describes it; source is not public |
| Bootstrap — install daemon, message gateway, persona system | Private | This docs repo describes it; source is not public |
The split lets the protocol gain adoption (it's a standard, with conformance rules and a published spec) while the integrator preserves IP defensibility.
Three-layer stack. Each layer solves exactly one problem and is independently useful.
┌─────────────────────────────────────────┐
│ INTERFACE LAYER │
│ Desktop · Mobile · Wearable · API │
├─────────────────────────────────────────┤
│ COGNITIVE LAYER │
│ Reasoning · Forge · Quorum │
├─────────────────────────────────────────┤
│ MEMORY LAYER │
│ Episodic · Semantic · Procedural │
├─────────────────────────────────────────┤
│ CORE LAYER │
│ Identity · Security · Ethics │
└─────────────────────────────────────────┘
Decentralized multi-agent coordination without a supervisor bottleneck. Agents publish typed intents to a shared graph and self-adjust based on stability scores — no inter-agent messaging required. Conflict detection is graph-level. Resolution is via four canonical Adjustment kinds or, when an adjustment isn't sufficient, a triumvirate vote with trust-weighted tallying.
This is the stigmergy pattern adapted to typed software intents.
- Spec:
quorum-protocol-spec-v0.1.md— full data model, stability scoring (deterministic), conflict detection rules, four-kind resolution protocol, triumvirate voting with three QuorumLevels, signal bus interface, conformance levels - Reference implementation:
convergentAIon PyPI — Python, ~926 tests at 97% coverage, optional Rust core via PyO3 for performance - License: MIT for both the spec and the reference implementation
Implementations in other languages are welcome. Cross-language conformance test suite is planned for v0.2.
Production orchestration for AI agent pipelines. Define workflows in YAML, assign token budgets per agent, set quality gates, and checkpoint state to SQLite for automatic resume on failure. Supports 10 agent archetypes, streaming execution logs, MCP tool execution, and persistent budget management.
Recent example: PR #41 (private) lifted GitHub's Effective-Tokens cost metric (ET = m × (1·I + 0.1·C + 4·O)) into Forge's BudgetManager with 16 unit tests — same-week public-frontier turnaround as an artifact, not a claim.
Persistent memory (episodic, semantic, procedural via ChromaDB), 40+ CLI commands, integrations (Google Calendar, Todoist, filesystem, webhooks), and a cognitive layer supporting Anthropic, OpenAI, and Ollama with native tool use. Core implements the constitutional principles P1–P9 that constrain all agent behavior in the system.
One-command install, Rich-based onboarding wizard, FastAPI+HTMX ops dashboard at localhost:7700, systemd/launchd service management. Phase 2 adds a message gateway with 8 channel adapters (Telegram, Discord, Slack, Matrix, WhatsApp, Signal, Email, WebChat). Phase 3 layers in proactive monitoring (6 self-healing checks), tool execution (37 built-in tools + MCP bridge), and automation pipelines. Phase 4 adds the persona engine with channel-aware routing.
- Persistence — context accumulates across sessions, devices, and years
- Sovereignty — cryptographic ownership, local-first by default
- Loyalty — aligned to you, not a platform's incentives
- Portability — moves with you across all devices
- Model independence — swap models without losing memory or context
Active development. Architecture stable.
| Component | Tests | Coverage | Visibility |
|---|---|---|---|
| Core | 2,329+ | 97% | Private |
| Forge | 9,795+ | 97% | Private |
| Quorum | 926+ | 97% | Open |
| Bootstrap | 1,857+ | 97% | Private |
Total: 15,000+ tests across 4 packages.
from convergent import Intent, IntentGraph
graph = IntentGraph()
# Two agents register their intents
graph.register(Intent(
agent_id="researcher",
intent="map the codebase structure",
provides=[InterfaceSpec(kind="DATA", name="codebase_map")],
stability=0.9,
))
graph.register(Intent(
agent_id="reviewer",
intent="review code for correctness and security",
requires=[InterfaceSpec(kind="DATA", name="codebase_map")],
stability=0.7,
))
# Find conflicts and let the protocol propose adjustments — no supervisor needed
report = graph.detect_conflicts(agent_id="reviewer")For the full protocol surface (triumvirate voting, signal bus, stability scoring, conformance), see the spec.
Budget-first execution. Every agent has a token budget. Every workflow has a cost ceiling. Inspired by Toyota Production System — make cost visible, make waste impossible to ignore.
No supervisor bottleneck. The industry default for multi-agent coordination is a supervisor that watches everything. This burns tokens on monitoring and creates a single point of failure. Quorum replaces this with environmental awareness — agents observe shared state and independently converge, the way flocking birds coordinate without a lead bird.
Checkpoint/resume. All Forge workflows persist state to SQLite. If a pipeline fails at step 4 of 6, it restarts at step 4. No wasted compute.
Provider-agnostic. LLM calls go through a shared interface. Swap Claude for OpenAI or Ollama without touching agent code. Native tool use dispatches by provider.
Local-first. Your memory, your identity, your hardware. Nothing leaves unless you configure it to.
Public artifacts that ground the test counts and architectural claims above:
- Quorum spec — full data model, stability scoring formula, conflict-detection rules, RFC 2119 conformance levels:
quorum-protocol-spec-v0.1.md - Quorum on PyPI —
pip install convergentAI. Test count + coverage verifiable in source distribution. - Active commit cadence — see AreteDriver's GitHub profile for public activity. 360+ commits in any given two-week window during active sprints.
- Architecture decisions — captured as ADL (Arete Decision Log) entries in the public notes repo.
The private repos (Forge / Core / Bootstrap) are not browsable. Code samples available on request for serious engagement; the spec + reference implementation cover the protocol layer.
Quorum protocol discussion welcome there. Issues and PRs against the reference implementation go to the (forthcoming) standalone quorum repo. Forge / Core / Bootstrap are not accepting contributions.
- Quorum spec: MIT
- Quorum reference implementation (
convergentAI): MIT - Forge / Core / Bootstrap: all rights reserved (private)
- This docs repo: MIT
James C. Young (ARETE) — github.com/AreteDriver — aretedriver@gmail.com