# One self-hosted memory server for every MCP agent.

Give Claude Code, Codex, Kiro, OpenCode, and other MCP clients one durable place
for **memory, session state, skills, corpus, coordination, and evidence**. Your
agents keep their own interfaces. The knowledge stays with you.

[Install Firekeep](https://firekeep.ai/self-hosted-mcp-memory-server.html#install) ·
[See the architecture](https://firekeep.ai/self-hosted-mcp-memory-server.html#architecture) ·
[Read the complete docs](https://firekeep.ai/docs.html)

Official MCP Registry · Loopback by default · One person or a team

Published and updated August 28, 2026 by the Firekeep team.

## The direct answer

Firekeep is a shared MCP memory server you operate.

Install the Client Kit on each machine and connect its local stdio gateway to
the same self-hosted Keep. Every client configured through a shipped adapter or
the generic local-stdio path can call the same memory, session, skill, corpus,
coordination, and evidence tools. Lifecycle automation varies by the hooks each
client actually exposes.

Firekeep is published in the
[Official MCP Registry](https://registry.modelcontextprotocol.io/v0.1/servers/io.github.kapella-hub%2Ffirekeep/versions/latest)
as `io.github.kapella-hub/firekeep`, using the `firekeep-client` package and
local stdio transport.

## Install a new Keep or join one already running

The installer asks for the agent identity attached to its work and where the
Firekeep server lives. It then configures Claude Code, Codex, Kiro, and
OpenCode together, plus Claude Desktop when the app is present.

macOS or Linux:

```sh
curl -fsSL https://firekeep.ai/latest/install | sh
```

Windows PowerShell:

```powershell
irm https://firekeep.ai/latest/install.ps1 | iex
```

Then:

1. **Name the agent.** Choose the identity recorded with memories, sessions,
   and replay events.
2. **Choose the server.** Provision this machine, redeem a single-use join
   code, enter an existing address, or finish later.
3. **Render the clients.** The shipped adapters are configured together; a
   generic MCP snippet is available separately.
4. **Verify the path.** Restart open agents, then run `firekeep doctor` to
   check the complete connection.

Follow the [complete installation walkthrough](https://firekeep.ai/docs.html#server)
for enrollment, server-only setup, source installation, checksums, and
troubleshooting.

## Architecture: local doorway, self-hosted core

Firekeep presents one stdio MCP server to the agent on each machine. That
gateway attaches identity, combines the shipped tool surfaces, and routes
requests to services in the Keep you operate. The server, datastores,
embeddings, and default inference run on your infrastructure.

1. **Your existing agents.** Claude Code, Codex, Kiro, OpenCode, Claude
   Desktop, or another client that speaks MCP.
2. **Local stdio MCP.** One Client Kit handles identity, routing, adapters,
   local dexes, and instructions on connect.
3. **Your self-hosted server.** Cortex, Bridge, Relay, and Sentinel connect
   memory, sessions, coordination, and replay.

A stock server binds to `127.0.0.1` and requires authentication on protected
routes. A join code can enroll another machine through the private route you
control; widening network exposure remains an explicit operator decision.
See the [full architecture guide](https://firekeep.ai/docs.html#architecture).

## What the shared Keep carries

- **Memory — keep what the work learned.** Durable reference, procedural,
  episodic, and transient memories stay connected to project, identity,
  provenance, and confidence.
- **Session state — return to where work stands.** Goals, plans, decisions,
  progress, and file notes survive context compression, machine changes, and
  cross-agent handoffs.
- **Skills — reuse how a problem was solved.** Agents can capture verified
  procedures as skills; document-derived drafts can enter a human review queue
  before publication.
- **Corpus — bring selected documents into recall.** Ingest internal material
  into the shared corpus or use Docdex to index chosen local folders with
  member-private visibility by default.
- **Coordination — give shared work clear ownership.** Tasks, messages,
  presence, handoffs, and renewable leases help cooperating agents avoid
  duplicate or overlapping work.
- **Evidence — inspect what passed through Firekeep.** Structured replay,
  declared outcomes, feedback, and evaluation receipts make Firekeep-mediated
  work traceable.

## One MCP tool surface, automation that matches the client

Direct calls to the Keep work through every shipped adapter and the generic MCP
path. Automatic briefings, capture, and edit mediation are separate: they
depend on lifecycle events the client makes available.

| Client | Connection and tools | Current lifecycle boundary |
| --- | --- | --- |
| Claude Code | Managed MCP, Firekeep instructions, and the full direct-call tool surface | Richest supported hook coverage; its pre-edit hook can hard-block a denied edit, write, or shell action |
| Kiro CLI | Named agent with managed MCP, steering, and the full direct-call tool surface | Lifecycle hooks are available; on validated Kiro CLI 2.12.1, pre-edit is advisory and there is no true session-end or pre-compaction event |
| OpenCode | Native adapter, local plugin, and the full direct-call tool surface | Supported edits can be blocked, but briefing and inbox output appear in the console rather than model context; no pre-compaction event |
| Codex | Managed MCP, repository guidance, and the full direct-call tool surface | No Firekeep hooks; recall, session updates, inbox polling, and policy calls are explicit MCP actions |
| Claude Desktop | Auto-detected when installed; its adapter mounts the full MCP tool surface | No hooks; it receives instructions on connect, while lifecycle calls and Docdex sync are explicit |
| Other MCP clients | `firekeep install --runtime generic` prints a paste-in local stdio configuration with the same tools and connect instructions | No hook lifecycle is implied; presence and heartbeat require the optional sidecar |

The boundary is simple: **MCP provides the shared capabilities; hooks provide
convenience and enforcement where the client supports them.** See the
[day-to-day runtime table](https://firekeep.ai/docs.html#usage) for the complete
current behavior.

## Actual requirements

The **Client Kit** runs on Linux, Windows, and macOS. The bootstrap includes its
own pinned Python toolchain, so system Python and Node are not prerequisites.

The **self-hosted server** requires:

- Docker and Docker Compose v2 with `linux/amd64` support.
- 2 x86-64 CPU cores minimum and Git.
- 16 GB RAM recommended for the default stack.
- x86-64 Linux, or Docker Desktop with amd64 support on Windows or Mac.
- No open ports; the default bind is `127.0.0.1`.

Review the current
[requirements and sizing notes](https://firekeep.ai/docs.html#requirements)
before choosing a host.

## A cross-runtime handoff

Suppose Claude Code diagnoses a difficult deployment failure. The next Codex
or Kiro session needs more than the final file—it needs the cause, the failed
approach, the verified recovery, and the current state of the work.

1. **Recall before acting.** The first agent checks the Keep for related
   decisions, procedures, and work already in flight.
2. **Capture the experience.** It records the goal, decisions, progress,
   verified fix, and why the earlier attempt failed.
3. **Start another runtime.** A later agent opens a session against the same
   workspace and recalls the relevant history.
4. **Close the loop.** It reports whether the knowledge held and leaves updated
   state for the person or agent who follows.

The handoff uses `ctx_start_session`, `memory_recall`, `ctx_update`,
`memory_learn`, and `memory_feedback` through MCP. See a complete
prompt-level example in the
[Claude Code to Codex handoff guide](https://firekeep.ai/claude-code-codex-shared-memory.html#handoff).

## Personal continuity and organizational knowledge

- **Individual — carry less context in your head.** Use one Keep across your
  own projects, agents, sessions, and machines. Decisions, active goals, chosen
  documents, and hard-won fixes remain available when you switch tools.
- **Team — earn context once and carry it forward.** Contributors add memories,
  reusable procedures, and selected corpus material to the same organizational
  knowledge layer. Proven experience can reach another role or runtime without
  a separate handover document.

The Keep improves through use without hiding uncertainty. Recorded session
outcomes and explicit feedback can influence which memories surface;
unconfirmed conflicts remain contested for human review. On a shared Keep,
Docdex folders are member-private by default within the workspace access model.

## Published evidence

On the accepted August 28, 2026 LongMemEval-S run, Firekeep measured **97.7%
Evidence Recall@10: 459 of 470 scored questions** returned at least one labeled
evidence session in the first ten results.

Read the number with its boundaries:

- It measures retrieval, not generated-answer accuracy.
- It is one corrected deterministic run, not a multi-run confidence interval.
- LongMemEval-S uses synthetic histories that differ from Firekeep's normal
  distilled production memories with provenance.

[Read the complete benchmark and methodology](https://firekeep.ai/longmemeval-benchmark.html).

In a separate five-month internal snapshot, Firekeep recorded **90 tracked
sessions in the latest month, 45 active operational skills, and 12 ingested
documents** across daily engineering and operations work. That is a dated case
study, not a benchmark.

[Read the daily-use case study](https://firekeep.ai/case-study.html).

## Self-hosting and license

Firekeep is **source-available under BUSL-1.1**, not open source today.
Self-hosted internal production use is free for individuals and teams during
early access, with no Firekeep account or license key required. Production use
outside that grant requires a commercial license. Each release converts to
Apache-2.0 four years after publication.

[Read the license](https://firekeep.ai/LICENSE.txt) ·
[View the public source](https://github.com/kapella-hub/FirekeepHQ)

## Frequently asked questions

### Is Firekeep an MCP memory server?

Yes. Each connected agent talks to a local Firekeep stdio gateway through MCP.
That gateway exposes memory, session, skill, corpus, coordination, and evidence
tools backed by the self-hosted Keep you operate.

### Does every MCP client receive the same automation?

No. Clients configured through a shipped adapter or the generic local-stdio
path can use the full shared direct-call tool surface. Automatic briefings,
lifecycle capture, and edit mediation depend on the hooks the client exposes.
Claude Code has the richest integration; Codex, Claude Desktop, and generic
clients use explicit MCP calls.

### Does Firekeep replace an agent's native memory?

No. Keep using runtime-native instructions, continuation, and provider context.
Firekeep carries the selected knowledge and working state that should survive
across agents, sessions, people, and machines.

### Can one person use a shared MCP memory server?

Yes. One person can use Firekeep across projects, runtimes, sessions, and
machines. Add teammates later when the same context should travel across
people.

### Where does the document corpus live?

Shared corpus content is stored in the self-hosted Keep. Docdex indexes only
folders a member chooses and makes them member-private by default. That is
application-level privacy from other members, not encryption from the server
operator.

### Is Firekeep open source?

Firekeep is source-available under BUSL-1.1. Self-hosted internal use is free
for individuals and teams during early access, and each release converts to
Apache-2.0 four years after publication.

## Related Firekeep guides

- [Provision or join a self-hosted Keep](https://firekeep.ai/docs.html#server)
- [Share memory between Claude Code and Codex](https://firekeep.ai/claude-code-codex-shared-memory.html)
- [Inspect the 459/470 retrieval result](https://firekeep.ai/longmemeval-benchmark.html)
- [Download Firekeep Studio for Windows](https://firekeep.ai/latest/studio/windows)
- [Download Firekeep Studio for macOS](https://firekeep.ai/latest/studio/macos)