The Hub-Spoke Matrix for
Enterprise Agents
Zero Cloud. Zero Leaks. Total Privacy. Single executable binary. Fast, secure, and powered by RAG natively. Standardize AI memory and functions across your organization using the Model Context Protocol (MCP).
$ lob-brain-rs --mode master --port 8080
▶ [INFO] LOB Master Hub initialized successfully
▶ [INFO] Listening for Spoke connections on 0.0.0.0:8080
▶ [MCP] Exposing 12 tools: [brain_store, brain_query, brain_context, brain_recall, ...]
▶ [POLICY] Loaded memory_policy from lob-brain.toml — 3 store_triggers active
▶ [SYNC] Spoke node "agent-backend-01" connected. Syncing federated context...
Hub-Spoke Federation
Two-layer architecture. Master Hub centralizes the global memory pool. Lightweight Spoke nodes sit on each engineer's machine, syncing upstream via Federation REST.
Native MCP Server
Not a wrapper — LOB Brain is the protocol endpoint. Exposes 12 tools for memory, RAG, sync, analytics, and session logging directly to Claude, Gemini, and any MCP-compatible agent.
12 MCP ToolsSelf-Governing Policy Engine
Define store_triggers and context_triggers in TOML. LOB dynamically injects these rules into MCP tool descriptions — the LLM learns when to save just by reading the tool definition.
100% Offline RAG & FTS5 Fallback
Two search paths that gracefully degrade. Semantic embeddings are generated locally via OS-level ONNX bridging — zero cloud calls, zero IP leakage. When ONNX isn't available, falls back to blazingly-fast SQLite FTS5 full-text search.
8.7MB Lite or Full Spoke
Two build modes via Rust feature flags. Lite (8.7MB) excludes ML deps, delegates RAG to Hub. Full (~120MB) includes local ONNX and operates independently. Both run the same 12 MCP tools.
Flawless Developer UX & Cross-Platform
Single binary execution with silent boot capabilities. Native support for Apple Silicon (ARM64), Windows, and Linux. IDE hooks auto-inject .cursorrules and mcp.json into Cursor, Windsurf, and VSCode.
Master Hub
Centralized DB & Global Sync
Spoke
8.7MB Lite Client
Spoke
Full Client
Local ONNXThe Two-Layer
Federation Matrix
LOB Brain physically divides AI context into two localized, high-performance layers to ensure absolute data sovereignty.
Master Hub Server
Deployed on your secure infrastructure. Controls policy engines, verifies Spoke access keys, maintains the global vectorized memory pool, and computes ONNX embeddings for incoming Lite Spoke data.
Edge Spoke Node
Installed on engineers' machines. Under 9MB RAM. Written purely in Rust. Connects to IDEs via MCP, executes real-time SQLite lookups locally, and syncs contextual memories upstream to the Hub.
Context Intelligence Engine.
LOB Brain doesn't just store — it actively manages, decays, and optimizes context to maximize LLM performance while minimizing token usage.
Context Decay Algorithm
Memories are assigned an importance score (1-5). Over time, less important facts naturally fade — freeing context windows for what matters.
Memory Reheating
When an agent recalls a memory via brain_recall, the decay timer resets. Like spaced repetition — useful information stays alive.
Token Budgeting
brain_context accepts a char_budget parameter. LOB fills the budget by decay rank, adjusting fidelity: full text → summary → essence.
# Zero file reads. Zero waste.
brain_context(project, 4000)
Context That Never Dies. Tokens That Never Waste.
Without LOB Brain, every new AI session starts from zero — re-reading files, re-explaining architecture, burning tokens. With LOB, context is loaded once and persists forever.
Without LOB Brain
- ▸Context lives only inside conversation history — once session ends, it's gone
- ▸New session = agent re-reads all project files from scratch every time
- ▸No ranking — agent loads files blindly, burning tokens on irrelevant context
- ▸Decisions & architecture choices must be re-explained in every new session
With LOB Brain
- ▸One API call loads all relevant context — ranked by decay score, fitted to your token budget
- ▸Decisions and architecture choices persist permanently in SQLite — never lost between sessions
- ▸Adaptive fidelity: full text → summary → essence based on available budget
- ▸Session 1 and Session 100 receive identical context quality — zero knowledge drift
∞
Memory Retention
0
File Reads Needed
~60%
Token Cost Saved
<50ms
Context Load Time
Pay Once. Own Your Context.
No monthly cloud fees for AI context. Your data stays on your machine, forever. Upgrade your memory capacity as you scale.
LOB Lite
Solo Personal Brain
or $149 Lifetime
- ✓ 15,000 Memories (Lifetime: Unlimited)
- ✓ 2 Devices (Hardware Locked)
- ✓ Local Spoke Mode Only
- ✓ Full Offline RAG
LOB Pro
The Power User
or $299 Lifetime
- ✓ 100,000 Memories (Lifetime: Unlimited)
- ✓ Up to 5 Devices
- ✓ Hub Sync Enabled
- ✓ Priority Support
Enterprise Hub
Small Agency / Startup
or Custom B2B License
- ✓ Unlimited Memories
- ✓ Unlimited Devices
- ✓ Hub Server Mode
- ✓ Multi-Tenant DB Support
Structured Memory Storage
LOB doesn't save raw chat logs. Every conversation is distilled into a structured semantic unit with content-addressable hashing, classification, and sensitivity control.
5 Memory Types
conversation · knowledge · learning · decision · architecture
AI-Driven Sensitivity
Agents auto-classify: public · internal · secret (SQLite only, never exported)
Markdown Knowledge Vault
Bi-directional sync between SQLite and .md files. Browse memories as a knowledge graph — compatible with Obsidian, Logseq, or any markdown editor.
{
"hash": "7c6a04ae",
"essence": "Self-Governing Policy Engine impl",
"summary": "Memory policy parsed from TOML...",
"importance": 4,
"memory_type": "architecture",
"sensitivity": "public",
"project": "lob-brain-rs",
"owner_id": "immaghost",
"decay_score": 58.5,
"tags": ["policy", "mcp", "toml"]
}12 MCP Tools. Zero Wrappers.
LOB Brain isn't a wrapper around another API. It is the MCP server — exposing persistent semantic memory directly to any compatible agent.
brain_store
Memory
brain_query
Memory
brain_recall
Memory
brain_context
Memory
brain_search
RAG
brain_ingest
RAG
brain_sources
RAG
brain_status
System
brain_clusters
Analytics
brain_snapshot
Cache
brain_log_session
Logging
brain_sync
Sync
Dynamic Tool Description Injection
LOB Brain's tool descriptions are not static strings. At startup, context_tools.rs reads your [memory_policy] from TOML and appends trigger rules directly into MCP tool metadata. When an LLM calls tools/list, it receives customized instructions — no prompt engineering needed.
# What the LLM sees when calling tools/list:
brain_store:
"Store a memory into the Brain."
"You SHOULD call this when:
• architecture decision
• bug root cause found
" ← injected from TOML
Project-Scoped
Access Control
Hub administrators create Ed25519 signed keys per project. Each Spoke is configured to access only its authorized projects — enforced at both the MCP tool level and the Federation REST endpoint.
Ed25519 cryptographic key verification
Double-gate enforcement (local MCP + remote Federation)
Multi-tenant isolation via project + owner_id scoping
Hub Admin
└─→ lob-license-cli
└─→ Signed Key
(project: "backend-team")
Spoke reads key from config
│
├── brain_query("backend-team")
│ └─→ ✅ Allowed
│
├── brain_query("finance-team")
│ └─→ ❌ Rejected (not in scope)
│
└── /federation_push to Hub
└─→ ✅ Syncs authorized data only