Built for small teams scaling fast, and enterprises that demand sovereignty.
Give product, strategy, operations, research, writing, support, legal, go-to-market, and engineering teams one governed memory layer across their AI assistants and internal agent platforms.
Physical per-team isolation.
Every team gets its own dedicated Postgres schema and isolated search index. One team’s memories and code graph are structurally separated from another’s, not merely filtered by a WHERE clause.
Granular privacy & sharing.
Users keep personal projects and private memories strictly private, grant named colleagues access to specific personal projects, or promote knowledge to their team, cross_team initiatives, or the enterprise.
Team & Enterprise Character Cast.
Build a shared cast of Team and Enterprise Characters for roles such as research, policy, product, support, writing, and architecture alongside private Characters. Enterprise Characters synthesize shared project context across teams while never seeing any user's private memories.
Shared Persistent Code Graph.
Index repositories across 19 languages into a team-scoped code graph, link architectural decisions directly to code symbols, and compute live local working-tree overlays via the client wrapper without exposing raw local paths.
Coherent team knowledge.
Brutha provides Git-style version control for shared memory. Its semantic conflict-resolution engine corroborates duplicate discoveries and flags contradictions before they pollute team recall.
Sovereign & audit-ready.
Runs on your own Postgres (including RDS, Cloud SQL, Supabase, and Neon with strict verify-full TLS). Includes full admin action logs, recall & privacy-filter audit logs, and PAT attribution.
One governed memory layer for the whole organization.
Product, strategy, and operations
Retain product decisions, customer research, meeting summaries, and roadmap context across teams and AI sessions.
Research, analysis, and writing
Synthesize long-running dossiers, import Markdown knowledge bases, and share approved Characters for consistent analysis and voice.
Support, legal, and go-to-market
Share curated facts, compliance guardrails, and approved company Characters while each user's scratchpad stays private.
Software engineering and architecture
Index repositories into the Persistent Code Knowledge Graph, map change impact, and link architecture decisions to code symbols.
Same local-first engine. Extended for multi-team governance.
| Capability | Brutha Solo | Team Edition | Enterprise Edition |
|---|---|---|---|
| Pricing Model | Free forever (optional Stripe donation) | $29 per seat/month billed annually, or $35 monthly. 5 to 25 seats. | $59 per seat/month billed annually for 25+ seats, or a custom annual license. |
| Storage Backend | SQLite (default) or Postgres | Postgres only (strict verify-full TLS for RDS / Cloud SQL / Supabase / Neon) | Postgres only, deployed on your controlled infrastructure |
| Tenancy & Isolation | Single user, single store | One dedicated team schema with a hard cap of 25 active seats | Unlimited schema-isolated teams with a licensed organization-wide seat pool |
| Role Hierarchy | Implicit single owner | Team administrators and members | Enterprise administrators, Enterprise Characters, team administrators, and members |
| Memory Visibility | Single owner | Per-memory private (owner-only) or shared (governed by project tier) via memory_set_visibility | Private and shared memory with cross-team governance and privacy-filter audit logs |
| Project Visibility | Workspace sub-scope | personal with per-user grants, plus team visibility | Personal, team, cross_team, and enterprise visibility with admin protection |
| Character Cast | Personal workspace personas | Private and shared Team Characters | Private, Team, and registered Enterprise Character identities |
| Cross-Team Collaboration | N/A | One licensed team | Named cross-team projects and governed grants with automatic fan-out in recall, search, and synthesis |
| Deployment Topologies | Local stdio or local HTTP | Direct stdio, or shared central HTTP daemon + lightweight client wrapper (brutha-enterprise-mcp-wrapper) with PAT enrollment | Central daemon and laptop wrapper, plus dedicated deployment architecture onboarding |
| Audit & Governance | Local hygiene logs | Seat, device, and license enforcement with team-scoped audit trails | Full recall and privacy-filter logs, PAT attribution, and CI/CD code-graph promotion |
One central daemon. Lightweight wrappers for every enrolled user.
Every tool call in Brutha Enterprise is bound to a verified team-member identity via Personal Access Token (PAT) enrollment or process-bound configuration, never left to an AI assistant to guess at runtime.
Central server + local working-tree overlay
Run one brutha-enterprise-mcp http daemon connected to your organization's Postgres. Team members who work with local repositories run the lightweight brutha-enterprise-mcp-wrapper binary locally, which authenticates via PAT, forwards MCP calls over HTTPS, filters secrets locally, and computes uncommitted git working-tree overlays on the user's machine.
STORAGE_BACKEND=postgres ./brutha-enterprise-mcp http --bind 0.0.0.0 --port 8080
Direct stdio against RDS, Supabase, Neon, or Cloud SQL
Each user's MCP client spawns brutha-enterprise-mcp over stdio pointed at your Postgres instance with strict verify-full TLS verification (fails closed on untrusted certificates).
POSTGRES_SSLMODE=verify-full
POSTGRES_SSLROOTCERT=/etc/ssl/certs/rds-ca-bundle.pem
BRUTHA_ENTERPRISE_USER=alice@example.com
BRUTHA_ENTERPRISE_DEFAULT_TEAM=engineering
CORE MEMORY & HYGIENE / primer, memory_save, memory_search, memory_recall, memory_expand, memory_link, memory_set_visibility, memory_synthesize, memory_decay, memory_token_savings, import_docs
CHARACTER CAST (PRIVATE / TEAM / ENTERPRISE) / character_save, character_update, character_activate, character_release, character_list, character_archive, character_set_visibility
TEAM & PROJECT GOVERNANCE / team_member_add, team_member_remove, project_set_visibility, project_grant_user_add, project_grant_user_remove
ENTERPRISE ADMIN & CROSS-TEAM / enterprise_admin_bootstrap, enterprise_admin_add, enterprise_admin_remove, team_create, enterprise_character_add, enterprise_character_remove, enterprise_character_list, cross_team_project_create, cross_team_grant_add, cross_team_search, personal_access_token_issue, personal_access_token_revoke, enterprise_stats
CODE 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
Signed licensing that works without a phone home.
Team and Enterprise deployments read an offline Ed25519-signed license from BRUTHA_ENTERPRISE_LICENSE_KEY or a local license file. Brutha verifies the signature against Ergonsun's built-in public key at startup. Any changed tier, seat limit, organization, feature, or expiry field invalidates the signature and the service fails closed.
1. Hard active-seat cap.
Membership and token enrollment are checked atomically against the signed seat allowance before another active user can join.
2. Per-user device limit.
Each licensed user may enroll up to two active devices, such as a desktop and laptop. A third device is rejected.
3. Seat-transfer cooldown.
Removed seats enter a seven-day transfer cooldown, preventing a small license pool from being rapidly rotated through a larger department.
4. Tamper-evident membership.
Membership records carry cryptographic integrity checks. Directly inserted or modified records fail verification during login and session startup.
5. Signed tier gates.
Team licenses are limited to one team. Cross-team projects, organization-wide sharing, and Enterprise Characters require an Enterprise license.
6. Solo store ownership.
Solo Postgres stores bind to one owner and machine, preventing a group from sharing one free store as an unlicensed team service.
Choose the plan that matches your team.
Start free as an individual AI user in any field, buy Team Edition for 5 to 25 seats, or contact us for Enterprise Edition onboarding across every role and department in your organization.
Team Edition
Dedicated team Postgres schema, shared Team Character cast, personal + team project visibility, team-scoped Persistent Code Knowledge Graph, and shared HTTP daemon + client wrapper deployment.
Billed annually at $348 per seat.
Enterprise Edition
Unlimited schema-isolated teams, cross_team and enterprise project sharing, cross-team Enterprise Characters, full recall/privacy audit logs, CI/CD --verify-commit code graph promotion, and dedicated architecture onboarding.
Individual users and professionals can download Brutha Solo for free right now and optionally support development via Stripe.
Go to free Brutha Solo download →