Your agent learns a lot. Let’s keep it that way.
Brutha gives every AI user a durable memory without giving their context away. It works with MCP-compatible assistants and self-hosted stacks across research, writing, analysis, product work, operations, support, legal work, go-to-market work, and software engineering.
Private by design.
Runs as a single local binary on your own machine. Your memories and code never leave the box: no third-party SaaS and no telemetry shipped to anyone.
Zero usage bill, zero LLM dependency.
Retrieval, deduplication, contradiction checks, synthesis gathering, and code mapping run locally at $0/query with no LLM calls in the memory path.
Memory that stays coherent.
Git-style version control for agent memory. Brutha's semantic conflict-resolution engine corroborates duplicate discoveries and flags contradictions so your agent can supersede stale facts.
Epistemic trust & active hygiene.
Memories carry provenance (user_stated, tool_verified, external_doc, agent_inferred) and age naturally (hot → warm → cold) without deletion. Weak recall confidence is flagged so agents ask instead of guessing.
Codebase & architecture awareness.
Generate token-budgeted structural repo maps across 19 languages, index repositories into a persistent code knowledge graph, trace blast radius (code_impact), and anchor memories directly to code symbols.
Cross-client & cross-model continuity.
Switch freely between supported AI clients, models, and your own local agent framework. Every tool shares the same memory store and portable Characters.
Not a pile of notes. A connected memory.
Scope knowledge to your work. Track who learned it. Link causal and related memories, check for source staleness against git commits and files, and take portable collections with you across projects and jobs.
workspace Your top-level context: company, venture, or personal (recalled globally alongside your active project).
project A focused sub-scope within a workspace.
agent Who learned it. Every memory carries provenance.
collection Portable knowledge your agents subscribe to across workspaces.
entity A canonical subject memories are about (person, repo, service, concept).
memory One atomic fact: typed, trust-weighted, and reconciled over time.
character A portable persona bound to an agent’s live memory collections.
A little character. A lot of consistency.
Give your agent values, habits, operating rules, and a personality that lasts. A Character follows its bound agent wherever Brutha does, with no more copy-pasting a soul.md between tools.
Set a workspace default to auto-load at session start. Characters inherit their agent’s memory subscriptions live, can carry an advisory preferred model hint (model: "provider/model"), and can be updated incrementally via character_update without overwriting existing instructions.
character_save(
slug: “jarvis”,
display_name: “JARVIS”,
content: “…”,
is_default_primer: true,
model: “provider/model”
)
character_update(slug: “jarvis”, content: “…”)
character_activate(slug: “jarvis”)
Persona + subscribed collections + model hint. Ready for the next session.
Different agents. One shared brain.
Built to be the shared memory layer for your entire AI workflow. Brutha returns compact snippets by default, expands only what you need, tracks your exact token savings in real time, and keeps your markdown notes and git repositories the source of truth.
56-58%
fewer recall tokens measured with compact snippets
39-72%
fewer search tokens in measured workloads
25-83%
lower task cost benchmarked with a memory broker
One store. Beyond MCP.
Run brutha-mcp http (or install it as a background OS daemon via brutha-mcp daemon install) to expose memory, Characters, and code maps over a local HTTP API so non-MCP frameworks share the same brain as your assistants.
Already have an Obsidian or Logseq vault? brutha-mcp import-docs <vault> indexes markdown sections as rename-resilient pointers while BRUTHA_AUTHORITY_SOURCES ranks your notes as top-trust.
Big memory. Smaller model.
Delegate broad recall, orientation, and synthesis to a cheap model. Keep quick facts and exact memory text inline. Your frontier model never has to read bulk memory.
./brutha-mcp install connects Brutha to your AI assistant. You can point broker.py at any OpenAI-compatible local or cloud endpoint and choose a fast, smaller model for memory work.
Your AI assistant
Run ./brutha-mcp install to connect a supported client and load the primer at session start. A fast, smaller model can handle broad memory orientation while your primary model stays focused on the task.
Any OpenAI-compatible stack
brutha-mcp http
export BROKER_BASE_URL=http://localhost:4000/v1
export BROKER_MODEL=<cheap-model-alias>
python broker.py “what do I know about X” --workspace <ws>
32 MCP tools. Long-term thinking.
A complete MCP toolkit for memories, epistemic hygiene, portable Characters, and persistent codebase intelligence.
CORE MEMORY & ENTITIES / memory_save, memory_search, memory_recall, memory_expand, memory_update, memory_supersede, memory_link, memory_forget, entity_upsert, entity_describe
HYGIENE, SYNTHESIS & ROI / memory_stats, memory_token_savings, memory_staleness_hints, memory_reconcile, memory_decay, memory_synthesize, end_session_review
CHARACTER PERSONAS / character_save, character_update, character_activate, character_release, character_list, character_archive
CODE MAP & KNOWLEDGE GRAPH / code_map, code_index_repo, code_search, code_symbol, code_neighbors, code_trace, code_impact, code_architecture, code_memory_link, code_memory_context, code_subscribe, code_outbox_claim, code_proposal_resolve
Useful in any field, for every AI-powered role.
Brutha keeps each person's working context ready for the next session. Use only the memory tools you need, or add code intelligence when your work includes software.
Product, strategy, and operations
Carry product decisions, customer research, meeting summaries, and roadmap context from one AI session to the next without repeating the background.
Researchers, analysts, and writers
Build long-running dossiers with memory_synthesize, import Markdown knowledge bases with import_docs, and keep a consistent working style with portable Characters.
Support, legal, and go-to-market
Remember approved facts, customer context, and policy guardrails while keeping private drafts and personal notes on your machine.
Software engineers and architects
Map repositories with code_map, check change impact with code_impact, and link architecture decisions to the code symbols they explain.
110x to 265x lower query cost. 88.1% fewer code-context tokens. 90.9% contradiction F1 at $0.
Chat-only memory services execute internal LLM synthesis or multi-step reflect loops inside the memory layer on every query, or call a cloud LLM on every write to normalize claims, costing $30 to $70+ per 1,000 queries while having zero understanding of source code structure or code-to-memory drift. Brutha performs hybrid retrieval, temporal filtering, write-time contradiction corroboration, and code-graph traversal locally at $0.00/query (0 LLM calls).
96.6%
Recall@5 (97.4% Recall@10, 0.975 NDCG@10) across 48 engineering questions and 214 memories (164 adversarial sibling & haystack distractors) in 34.1ms p50 with 0 LLM calls and 0 expired or superseded leaks.
88.1%
fewer agent context tokens (14,650 vs. 122,691 tokens) and 84.9% fewer tool calls (15 vs. 99 calls) with 100% ground-truth recall across call-chain trace, blast-radius impact, and code-to-memory drift detection.
90.9% F1
96.8% recall & 85.7% precision on the 106-pair external real-prose contradiction benchmark (and 0.0% sibling false-positive rate / 93.3% precision on the 91-pair Route 1 suite) with 0 LLM calls and 0 false hard-blocks.
Pillar 1: Reader-Stratified QA Accuracy & Cost per 1,000 Queries
Evaluated live across all 48 questions (32 answerable knowledge updates, temporal validity, and 2-to-4 hop synthesis questions + 16 unanswerable out-of-domain and adversarial in-domain near-miss queries) under strict all-hops grading:
| Configuration | Memory-Layer LLM Calls | Memory Cost / 1k Queries | Reader Cost / 1k Queries | Total Cost / 1k Queries | Retrieval Recall@5 | Abstention Accuracy | Strict End-to-End QA |
|---|---|---|---|---|---|---|---|
| Brutha Tier-1 Pure Retrieval (No LLM) | 0 across write and query | $0.00 | $0.00 | $0.00 | 96.6% | 100% OOD / 0% ID* | Direct MCP Snippets |
| Brutha + Local Open-Weights (Llama 3.1 8B) | 0 | $0.00 | $0.00 (local) | $0.00 | 96.6% | 100.0% (16/16) | 68.8% (33/48) |
| Brutha + Local Open-Weights (Llama 3.3 70B / DeepSeek V3) | 0 | $0.00 | $0.00 (local) | $0.00 | 96.6% | 100.0% (16/16) | 77.1% (37/48) |
| Brutha + Cheap Cloud Reader (Claude Haiku 4.5 Broker) | 0 | $0.00 | $0.27 | $0.27 | 96.6% | 100.0% (16/16) | 91.7% (44/48) |
| Brutha + Frontier Cloud Reader (Claude Sonnet 4.6) | 0 | $0.00 | $3.22 | $3.22 | 96.6% | 100.0% (16/16) | 89.6% (43/48) |
Competitor Ref: Ergo (ergomem) LLM-Normalized Write Path | 2 LLM calls / write | Cloud LLM required on write | N/A | N/A | N/A | N/A | N/A |
| Competitor Ref: Honcho Synthesis Endpoint | 1 to 3 internal calls | $25.00 | $5.16 | $30.16 | N/A | N/A | N/A |
| Competitor Ref: Hindsight Reflect Loop | 3 to 8 internal calls | $65.00 | $6.96 | $71.96 | N/A | N/A | N/A |
Pillar 2: Code Knowledge Graph & Memory Drift Token Efficiency
| Engineering Task Category | Tasks | Code-Graph Context Tokens | Baseline rg + File Read Tokens | Token Reduction | Tool Calls (Graph vs. Base) | Ground-Truth Recall |
|---|---|---|---|---|---|---|
| Call-Chain & Execution Trace (code_trace) | 5 | 3,610.8 | 33,731.0 | 89.30% | 5 vs. 33 | 100.0% (5/5) |
| Blast-Radius Impact Analysis (code_impact) | 5 | 4,673.5 | 41,401.2 | 88.71% | 5 vs. 36 | 100.0% (5/5) |
| Live & Commit Code-to-Memory Drift (code_memory_context / memory_staleness_hints) | 5 | 6,366.0 | 47,558.8 | 86.61% | 5 vs. 30 | 100.0% (5/5) |
| All 15 Engineering Tasks (Total) | 15 | 14,650.2 (58.6 KB) | 122,691.0 (490.8 KB) | 88.06% | 15 vs. 99 (-84.85%) | 100.0% (15/15) |
Pillar 3: Write-Time Contradiction Detection (0 LLM Calls vs. LLM-Normalized Alternatives)
| Benchmark Suite & System | LLM Calls / Pair | Write Cost / 1k Pairs | Precision | Recall | F1 Score | Sibling / Hard-Block Errors |
|---|---|---|---|---|---|---|
| Brutha (Zero-LLM Write Path) on Ergo's 106-Pair Real-Prose Suite | 0 | $0.00 | 85.7% (30/35) | 96.8% (30/31) | 0.909 | 0 false hard-blocks (94.3% accuracy, deterministic) |
| Brutha on 91-Pair Technical Contradiction Suite | 0 | $0.00 | 93.3% (14/15) | 82.4% (14/17) | 0.875 | 0.0% (0/61) sibling false-positive rate |
Ergo (ergomem LLM-Normalized Mode) on 106-Pair Real-Prose Suite | 2 LLM calls / pair | ~$0.80 | 80.0% to 86.0% | 77.0% to 84.0% | 0.790 to 0.830 | Non-deterministic LLM band; requires cloud LLM on write |
Ergo (ergomem Heuristic-Only 0-LLM Mode) | 0 | $0.00 | Fails on implicit / paraphrased prose contradictions without LLM normalization | N/A | N/A | Heuristic-only write path |
1. LongMemEval-Adapted Engineering Suite: Adapted from the ICLR 2025 LongMemEval taxonomy for software engineering workflows. Evaluates 48 queries (9 knowledge updates via memory_supersede, 7 temporal validity windows via valid_from/valid_until, 16 multi-session 2-to-4 hop synthesis chains, 8 out-of-domain abstentions, and 8 adversarial in-domain near-miss abstentions) against a 214-memory haystack containing 164 competing sibling-service and engineering distractors. Zero post-hoc filtering; Tier-2 readers are graded strictly on 100% required multi-hop fact presence and 100% abstention on unanswerable queries.
2. Code-Graph & Drift ROI Suite: Evaluates 15 deterministic engineering tasks against a real multi-crate Rust repository (1,915 indexed AST symbols, 6,719 call/import edges, 73 files) comparing actual JSON-RPC response payload bytes/tokens (chars / 4) of code_trace, code_impact, code_memory_context, and memory_staleness_hints against an equivalent ripgrep (rg) + 120-line file-slice baseline.
3. Epistemic Hygiene Suites: Evaluates both the 91-pair Route 1 technical suite (61 sibling coexisting facts, 17 genuine conflicts, 11 duplicates, 2 unrelated) and the external 106-pair myzona-org/ergomem evals/prose/dataset.jsonl suite (31 genuine contradictions, 15 near-miss precision traps, 60 harvested real-corpus false positives) through the exact same zero-LLM brutha-mcp binary with domain-neutral structural and dual-model NLI corroboration.
# Measure live token savings and code-graph ROI on your own workspace:
brutha_memory_token_savings(scope="all_time")
brutha_code_index_repo(path=".")
brutha_code_impact(symbol_key="...")
Start solo. Add a team when the work becomes shared.
| Edition | Solo | Team | Enterprise |
|---|---|---|---|
| Price | $0, free forever | $15 per seat billed annually, or $25 per seat/month billed monthly | $39 per seat/month annually or custom annual contract |
| Support & Onboarding | Self-serve documentation at /docs | Email support included at support@ergonsun.com | Guided onboarding included, with optional annual Technical Support renewed yearly |
| Best for | Individual users and professionals | 5 to 25 seats | 25+ seats and multiple teams |
| Knowledge scope | Personal memory, Characters, and Code Graph | One shared team with private and team visibility | Cross-team and organization-wide governed sharing |
| License | Single-owner local store | Offline signed key with hard seat and device limits | Offline signed key with enterprise tier controls |
Building with a small team or enterprise?
Brutha Solo is free forever for individuals in any field (supported by optional Stripe donations). When people across your organization want a shared institutional brain without giving up each user's privacy, choose Brutha Team or Enterprise: physical per-team Postgres schema isolation, governed project sharing, a shared Team and Enterprise Character cast, cross-team collaboration grants, and an optional team-scoped Persistent Code Knowledge Graph running on your own infrastructure.