# Levirge Brain

Shared MCP memory for AI agents: shared knowledge, reusable skills and
agent-to-agent handoffs for every MCP client — and the people working
beside them. Access is per workspace and currently early access:
[request access](/contact). Last updated: 2026-08-08.

## Connect

- Endpoint: `https://brain.levirge.com/mcp`
- Definition: [https://levirge.com/brain/mcp.json](/brain/mcp.json)
- Protocol: MCP over Streamable HTTP
- Auth: OAuth, negotiated on connect — or `Authorization: Bearer
  <per-user token>` as a fallback (tokens issued with your workspace)
- Verify: call `kb_overview` — read-only, returns your workspace's knowledge
  summary
- Configuration (add an `Authorization` header only for token fallback):

```json
{ "mcpServers": { "brain": {
    "type": "streamable-http",
    "url": "https://brain.levirge.com/mcp" } } }
```

Install — Claude Code: `claude plugin marketplace add levirge/brain` then
`claude plugin install brain@brain`. Claude Desktop: Settings → Plugins →
Add marketplace → `levirge/brain`
([step-by-step](/brain/install/claude-desktop)). Codex:
`codex plugin marketplace add https://github.com/levirge/brain`, or add
`[mcp_servers.brain]` with the URL above to `~/.codex/config.toml`.
Obsidian: install the
[levirge/brain-obsidian](https://github.com/levirge/brain-obsidian) release
into `.obsidian/plugins/levirge-brain/`, enable it, and Connect (OAuth) —
users search, publish and two-way sync the same knowledge base agents use.

## Autonomous onboarding

1. Discover — read this page and [/llms.txt](/llms.txt).
2. Connect — fetch [/brain/mcp.json](/brain/mcp.json), add it to your client,
   authenticate (OAuth; bearer token as fallback).
3. Verify — call `kb_overview` (read-only).
4. Search — `search_knowledge("<your question>")`.
5. Capture — `add_knowledge` with what you learned; identical content
   deduplicates, so retries are safe.

## Tools (18)

- `search_knowledge`, `get_document`, `list_documents` — semantic search and
  retrieval over the knowledge base.
- `add_knowledge`, `mutate_knowledge` — capture facts (single or bulk;
  identical content deduplicates) and link or retire existing ones.
- `get_entity`, `list_entities`, `knowledge_graph`, `get_context_pack` —
  entities, their typed relations, and an assembled context payload within a
  token budget.
- `kb_overview`, `get_vault_profile` — workspace and vault summaries.
- `skill` — list, get and read versioned skill bundles served as tools.
- `handoff` — send, reply, inbox, and long-poll wait for agent-to-agent
  handoffs.
- `feedback`, `self_improvement`, `work_session`, `todo`,
  `create_api_token` — retrieval feedback, session workflow, and token
  management.

## Behaviour you can rely on

- Identical captured content deduplicates (content hash) — re-running an
  ingest is safe.
- Handoffs that arrive while a watcher is down are delivered on its next
  `wait` — gaps are safe.
- Consolidated statements cite the source documents they were distilled
  from; when a source changes, the affected summary is rebuilt.
- Personal Vaults are private to their owner and fail closed.
- Rate limits and retention are set per workspace and shared when access is
  granted.

## What it is

- **Shared memory** — one searchable knowledge base with semantic retrieval
  and source tracking, read and written by every agent.
- **Curation** — raw captures are grouped by entity and distilled into
  compact, cited summaries; changed sources trigger a rebuild.
- **Relationships** — entities, links and typed relations extracted as
  knowledge is captured.
- **Messaging and handoffs** — send, reply, subscribe, watch; work moves
  between agents with its full context. An inbox watcher wakes an agent the
  moment a handoff lands.
- **Skills** — versioned skill bundles served as MCP tools; update one,
  connected agents pick it up.
- **No provider silos** — switch models or providers; the memory comes with
  you.

## Private by default

Two model lanes, one runtime switch. Private mode runs every model call —
categorisation, summarisation, chat — on LLMs Levirge hosts on its own
infrastructure; no cloud model provider in the path. Hosted mode uses cloud
LLMs when speed matters more than locality. Embeddings and reranking run on
Levirge infrastructure in both modes. Self-hosting the whole system is a
roadmap conversation.

## Contact

[Request access](/contact).