# 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/docs/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) —
it two-way syncs a local vault against the same knowledge base agents use —
local edits push, remote changes pull, conflicts park side by side.

## 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 (19)

- `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.
- `reminder` — add, list, complete and delete dated reminders. A reminder is
  invisible until its `due` date, then returned by `list` (with `within_days`
  to look ahead); `links` attach the documents the reminder is about. Brain
  answers what is due — it does not notify, email or wake anything, so acting
  on a due reminder is a scheduled agent's job. For work owed now, use `todo`.
- `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. Measured
  before/after on one query: [dense results](/brain/examples/dense-results.md).
- 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 makes it different

Brain is a work-continuity system, not a memory store. Four things carry that:

- **Memory and work in one substrate** (shipped) — `work_session`, `todo`,
  `skill`, `handoff` and `reminder` sit on the same server as the knowledge
  base, so an agent starting cold can recover what it was doing, what is still
  owed, the procedure to follow, what another agent left it, and what falls due
  later.
- **Scoped per project, not per person** (shipped) — knowledge is partitioned
  by Vault, one per project, product or client; a whole team shares one, and
  unrelated projects stay out of each other's answers.
- **Humans curate where they write** (shipped) — the Obsidian plugin two-way
  syncs a local vault against Brain: local edits push, remote changes pull, and
  a genuine conflict parks the remote copy beside the local file.
- **Git-backed Vaults** (planned, not shipped) — a readable markdown mirror of
  each Vault committed to a git repo you can hold: diffable, revertible, and
  its own exit hatch. Designed as of Aug 2026; storage today is Levirge-hosted
  and tenant-isolated. Restore from a remote is not available yet. Also planned
  on top of it: a Vault we manage can push-mirror to a repository you control
  (your GitHub, GitLab or own server) — we hold the working copy, you hold a
  continuously updated replica.

## Shared, not personal

The Vault is the team boundary: several people, each running their own agents
and clients, read and write one Vault. Shipped today — shared Vaults, per-user
tokens you issue and revoke, and handoffs that carry work between agents and CI
workers. In build, and deliberately not claimed as available: per-writer
attribution on facts, per-token read-only/read-write scoping, and git-backed
diff-and-revert review of what agents wrote.

## 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. Hosted mode runs every model call —
categorisation, summarisation, chat — on LLMs Levirge hosts on its own
infrastructure; no third-party model provider in the path. Cloud mode uses
third-party 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).