Skip to main content
Glama

AllBrain Agent Runtime

One brain. Many agents. One shared memory.

CI PyPI Downloads Python License Ruff

AllBrain Agent Runtime banner

demo

Without AllBrain vs with AllBrain

Scenario

Without AllBrain

With AllBrain

Agent A saves a plan

Written to local chat history, immediately lost when session ends

Appended to shared event store via save_event()

Agent B starts the same project

Fresh context — no knowledge of Agent A's work

resume_project() returns full event history

Two agents write conflicting changes

Silent overwrite, no one knows

detect_conflicts() surfaces both versions

Handoff between agents

Manual copy-paste of context

list_events() with agent filter shows handoff trail

Debugging state drift

"It worked in my session"

Deterministic replay from raw events, exactly reproducible

Related MCP server: Enhanced Sequential Thinking MCP Server

The problem

Your AI coding agents don't talk to each other. Agent A saves a plan, Agent B starts fresh, Agent C has no idea what happened. Each agent works in isolation, repeating mistakes and missing context.

AllBrain gives every agent a shared workbench. Each tool call is recorded in an append-only event store. When the next agent arrives, it sees everything that happened before — events, sessions, conflicts, decisions — and picks up cleanly.

What AllBrain gives you

  • Shared memory — save_event, list_events, resume_project across any MCP client

  • Agent attribution — every event is tagged with the agent that wrote it

  • Conflict detection — automatic surface of conflicting state updates

  • Decision pipelines — counterfactual reasoning, scenario planning, foresight

  • Deterministic replay — rebuild project state from raw events

  • 53 tools in full profile across 18 domain modules (start with 3, enable more as needed)

30-second demo

# Agent A: save a plan
uv run allbrain start --project . --agent agent-a
# In Agent A's client, call:
#   save_event(type="task_planned", payload={"task": "implement auth"})
# Agent B: see what Agent A did
uv run allbrain start --project . --agent agent-b
# In Agent B's client, call:
#   list_events()
#   resume_project()

See examples/two_agent_sqlite_pilot.py for a full two-agent workflow with conflict detection and replay verification.

Install for one client

The PyPI distribution is allbrain-agent-runtime. The canonical CLI command is allbrain; allbrain-mcp and allbrain-agent-runtime remain compatibility aliases for existing installations and scripts.

uvx allbrain-agent-runtime install --codex

This configures Codex to start AllBrain automatically. Replace --codex with the client name:

Client

Flag

Codex

--codex

Claude Code

--claude

OpenCode

--opencode

Cursor

--cursor

VS Code

--vscode

Zed

--zed

Gemini CLI

--gemini

Kiro

--kiro

Windsurf

--windsurf

Antigravity

--antigravity

Claude Desktop

--claude-desktop

Use --all to configure every supported client at once.

Verify it works

uvx allbrain-agent-runtime install --codex --verify

The --verify flag starts the server, saves a test event, reads it back, and confirms shared memory is working.

Tool profiles

Start with --tool-profile minimal (3 tools) and expand when needed:

Profile

Tools

Use when

minimal

save_event, list_events, resume_project

Getting started

memory

minimal + retrieve_memory

Need recall

collaboration

memory + task/conflict/resolution tools

Multi-agent handoff

reasoning

memory + decision pipeline tools

Planning and analysis

core

save_event, list_events, retrieve_memory, git_info, create_task, get_task_graph, orchestrate_project, run_decision_pipeline, create_snapshot, resume_project, get_context_pack

Essential workflow + context pack

full

53 tools

Complete surface across all 18 tool modules

uv run allbrain start --project . --agent my-agent --tool-profile memory

Glama MCP Portal

Glama MCP evaluates this server with the balanced core tool profile (--tool-profile core in glama.json). Its 11 public tools cover shared memory, task orchestration, snapshots, Git context, and decision workflows without exposing the entire development surface.

For local development or to access all capabilities, use the full profile:

uv run allbrain start --project . --agent claude-code --tool-profile full

Alternatively, standard client configurations like .mcp.json (which default to full) can be used.

From source

git clone https://github.com/Mustafa-Ali-Ertugrul/allbrain-mcp.git
cd allbrain-mcp
uv sync
./scripts/install-mcp.sh --all --isolate --verify

Or run the guided onboarding wizard:

uv run allbrain onboard

It walks you through client selection, install, verification, and your first event step by step.

See the full setup guide for manual config, troubleshooting, and shared-vs-isolated databases.

First memory save

Once AllBrain is installed and the client is restarted, call:

save_event(type="task_started", payload={"task": "implement auth", "agent": "codex"})

Then verify it was recorded:

list_events()

Switch to another client, call list_events() again — the same event appears.

Tool count and supported clients

Note: Glama evaluates the balanced 11-tool core profile. The full profile remains available for local development.

  • 53 tools in the full MCP profile across 18 server tool implementation modules (src/allbrain/server/tools/)

  • Default profile (full) registers all tools

  • minimal profile: 3 tools (save_event, list_events, resume_project)

  • core profile: 11 tools (essential workflow + reasoning + context pack)

What's New in v1.1.0

Security hardening (threat-model remediation)

  • Fail-closed sanitization (§B1): Depth-limit bypass closed; configurable max depth and payload size cap.

  • gitbrain RCE sandbox (§D): No-shell argv, hard env isolation, and dangerous git config overrides.

  • SQLite permissions (§E1): Restrictive file/dir modes and umask hardening (Windows best-effort documented).

  • Memory poisoning defense (§1): Event-sourced quarantine, default exclusion from context, untrusted event boundaries, promote_event / review_quarantined.

  • Safe install (§C1): .mcp.json backup + merge + confirm/--force + integrity hash.

  • Windows path hardening (§C2): Case-insensitive normcase + realpath containment checks.

  • Event hash-chain (§A2): Lightweight tamper-evidence via chained payload hashes.

Runtime changes

  • Full tool surface: 53 tools (promote_event, review_quarantined added)

  • list_events default limit raised to 1000

  • CI matrix: Python 3.12 & 3.13, coverage gate 85%

What's New in v1.0.0

1. 6 Bounded Contexts & 73 Domain Modules Migration

  • Modular Namespace: All 73 domain packages have been reorganized into the canonical allbrain.domains.* namespace across 6 bounded contexts: reasoning, analysis, learning, governance, memory, and collaboration.

  • Backward Compatibility Shims: Root imports (allbrain.<module>) remain functional with DeprecationWarning and are slated for removal in v2.0.0.

2. High-Performance Benchmarks & FastMCP Engine

  • Cold Startup: $\le 0.11$s server initialization.

  • Throughput: 277–371+ eps across varying payload sizes on local SQLite WAL.

  • Snapshot Generation: 0.091s for 10,000 events.

  • Memory Footprint: ~150 MB RSS peak under concurrent load.

3. Production Security & Verification

  • Secret Redaction: Multi-layer masking for 13+ secret formats and Pydantic validation error sanitization.

  • Input Validation: Strict Pydantic models with null-byte rejection and prompt injection filtering across MCP tools.

  • Filesystem Sandbox: ALLBRAIN_ALLOWED_PROJECT_ROOTS path traversal isolation.

  • Dual-Window Rate Limiting: Process-local thread-safe rate limiter (1,000 RPS burst, 100,000 RPM rolling).

Community

Data lifecycle and security

AllBrain stores events, sessions, and audit logs in local SQLite. Data never leaves your machine. Credential-like values are redacted before storage.

Advanced docs

Status

  • 3,110 passed tests, 5 skipped tests (100% green)

  • 53 tools in full profile

  • stdio FastMCP handshake verified

  • Python 3.12 & 3.13 (CI matrix)

  • Coverage: 86.54% (enforced threshold 85%)

  • Released under MIT · all releases are reproducible from the tagged source

Available Tools

5 tools
create_taskA

Create a new task in the event-sourced task graph for multi-agent orchestration.

Use this to add work items before assigning them to agents. For updating an existing task's priority, use change_task_priority instead. This appends a TASK_CREATED event to the append-only SQLite event log with stable UUIDv7 ordering.

Side effects: Creates a TASK_CREATED event in the project's event log. Triggers an automatic snapshot when the event threshold is reached. Does NOT assign the task.

Inputs: goal (required), kind, task_id, priority, +1 more. Returns: object

git_infoA

Retrieve git repository context, working tree status, or recent changes.

Consolidated tool replacing the previous get_git_context, get_git_status, and get_recent_changes tools. Use info_type to select what subset to return.

"all" returns branch, remote, recent commits, working tree status, and staged/ modified/untracked file lists in a single response. Use this when you need the full picture before making changes.

Side effects: Read-only operation; queries git repository.

Inputs: limit, since, until, info_type. Returns: object

list_eventsA

Query and filter recorded events from the append-only event log.

Use this to inspect the history of agent actions and system state changes. Events are ordered by stable UUIDv7 timestamps for consistent replay.

Side effects: Read-only operation; no data is modified.

Inputs: type, limit, session_id. Returns: object

retrieve_memoryA

Semantic search over stored memories to find similar workflows and patterns.

Use this to discover relevant past work when facing a new task. Returns both similar workflows and common failure patterns that match the query.

Side effects: Reads from the semantic memory store built by build_memory. Use build_memory first to ensure the index is up-to-date.

Inputs: query (required), limit, top_k. Returns: object

save_eventA

Append an event to the shared event log with optional metadata.

Use this to record agent actions, decisions, and state changes. All events are append-only with stable UUIDv7 ordering, enabling deterministic replay.

Side effects: Creates a new event in the SQLite event log. Triggers an automatic snapshot when the event threshold is reached. This is the primary write operation for the event-sourced architecture.

Inputs: type (required), payload (required), branch, source, +6 more. Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 5 tools

    Disambiguation5/5

    Each tool targets a distinct function: event logging (save/list), git context, semantic memory retrieval, and task creation. There is no overlap or ambiguity in their purposes.

    Naming Consistency3/5

    Most tools follow a verb_noun pattern (save_event, list_events, retrieve_memory, create_task), but git_info breaks this pattern as a noun phrase, introducing inconsistency.

    Tool Count4/5

    With 5 tools covering event log, git, memory, and tasks, the count is within the typical 3-15 range but feels slightly thin given the broad scope, making it reasonable but not well-scoped.

    Completeness3/5

    The event log is complete with save and list, but git lacks write operations, memory lacks a creation tool (build_memory is referenced but not present), and tasks lack update, delete, or list operations, leaving notable gaps.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      Enables efficient code navigation and retrieval through natural language search, BM25 ranking, and fuzzy matching across multiple programming languages. It drastically reduces token usage by allowing Claude to query specific code symbols and logic instead of reading entire files.
      13
      13
      MIT
    • F
      license
      A
      quality
      D
      maintenance
      A durable multi-agent orchestrator for software development with explicit run graphs, checkpoint/resume capabilities, and project memory exposed through MCP resources and tools. It enables coordinated agent workflows for coding, review, repair, CI, and approval with SQLite-backed memory retrieval and pluggable research backends.
      10
      -