The memory layer AI agents can trust.

Kumiho gives every agent a shared, versioned memory graph — so facts can be traced, corrected, and trusted across tools.

Formal belief revision · typed provenance · local-first

Install Kumiho DesktopWatch the 2-min demoRead the paper

Free · Windows / macOS / Linux · installs Community Edition for you

Kumiho Desktop — the cross-platform app open to the Kumiho Brain memory constellation: 1,079 typed memories, a live registration feed, server and brain status, running Community Edition locally
Kumiho Desktop — one app for Kumiho Cloud & Community Edition · Windows / macOS / Linux

  • 93.3%

    LoCoMo-Plus accuracy

  • 49/49

    AGM scenarios passed

  • AWS

    research citation

  • Local

    nothing phones home

Agents forget. Vector stores can’t say why they remember.

Flat similarity search breaks on exactly the questions long-running agents get asked. One root cause: memory without structure.

multi-hop“Who reviewed the PR that introduced the auth regression?”
The answer chains facts across memories. Similarity search retrieves fragments; nothing connects them.
temporal“What had we decided before the pivot?”
Embeddings have no timeline. Without valid-time, “latest” and “true back then” blur into one.
belief update“We moved to gRPC — why does half the store still say REST?”
Append-only memory accumulates contradictions. A real update revises what depended on the old belief.

Kumiho connects facts across relationships, time, and revisions — not just similarity.

One graph. Every surface.

Kumiho is the memory engine — a shared, versioned graph. Everything else is a surface on that same graph.

the core

Kumiho Memory Engine

The shared, versioned memory graph

Inside the memory engine

A cognitive memory core, not an embedding cache.

Every capture is a typed, versioned node in a provenance graph. When the world changes, memory is revised — formally — instead of contradicting itself.

Belief revision, proven
AGM-compliant revise/contract/expand — 49/49 compliance scenarios pass against the shipped engine.
Write-time ontology
Facts, decisions, and relations are extracted when memory is written, not guessed at recall time.
Two reflexes, any agent
engage before responding, reflect after — one MCP server plugs into Claude Code, Codex, or your own stack.
pip install kumiho-memory
Read the docs

Built on Kumiho

Revka

A memory-native runtime for governed agent workflows.

Agent workflows with a tamper-evident audit trail — every run remembered in the same graph.

Drives the CLIs you already use

  • Claude Code
  • Codex
  • Antigravity
  • Cursor
  • OpenCode
curl -fsSL https://revka.ai/install.sh | bash -s -- --prefer-prebuilt
revka.aiGitHub

How it works

Your files and conversations stay where they are. Kumiho keeps the structure: what was learned, decided, and changed — and what depends on what.

  1. Your agents

    Claude Code · Codex · Cursor · your stack

  2. MCP / SDKs

    engage before, reflect after

  3. Kumiho graph

    typed nodes · provenance edges · versioned beliefs

  4. Recall · Audit · Events

    reliable recall · auditable answers · event triggers

Write-time ontology

A typed knowledge graph built at save-time — not embedding soup sorted out at recall.

Decision Memory

Why is the code like this? Ask it. Decisions anchor to commits and files, with evidence and rejected alternatives attached.

decision

Use gRPC for internal services.

why lower latency, generated contracts

rejected REST — inconsistent schemas

Multilingual recall

Native Korean morphological search with typo-tolerant matching. Store in the language you think in.

One command backfills your entire AI history into a live memory graph.

New · the desktop app

Kumiho Desktop — the entry point to your whole Kumiho stack.

One cross-platform app that connects to your Kumiho Server — Kumiho Cloud or a self-hosted Community Edition — and opens straight to your live memory constellation. From here you run the whole family: Revka today, with 9Miho and Kumiho Browser on the way.

What Kumiho Desktop opens to — the graph breathing in real time.
Every platform, auto-updating
Windows, macOS (Apple developer-signed), and Linux from one build — it updates itself in place, no reinstalls.
Cloud or Community Edition
Point it at Kumiho Cloud or your own self-hosted server. Same app, same graph — your choice of where it lives.
Opens to your memory
The Kumiho Brain constellation is the home screen — memory vitals, spaces, live feed, and RECALL the moment you launch.
Runs the whole family
The launch point for every Kumiho app — Revka now, 9Miho and Kumiho Browser next — all on one shared graph.
Get Kumiho DesktopSee the memory terminal

Windows · macOS · Linux · auto-updating

Receipts, not adjectives.

Every number below links to a public artifact you can re-run. Where a peak isn’t reproducible on today’s models, we say so — and don’t quote it.

93.3%

LoCoMo-Plus judge accuracy

Full 401-entry cognitive-memory benchmark: contradiction handling, belief updates, time awareness. Gemini-2.5-Pro with a 1M context scores 45.7% under the same protocol.

Benchmark harness + results

LoCoMo — a separate benchmark, scored in token-F1 (all 1,986 questions)

SystemMulti-hopOverall
Kumiho0.3610.531
Mem00.286~0.40
Mem0-Graph0.243~0.40
Memobase0.229—
Zep0.194—

Token-F1 is a 0–1 scale — not comparable to the judge-accuracy percentage above. Kumiho row: reproducible today on the shipped stack, answer model pinned to gpt-4o-2024-08-06. Baselines as reported in LoCoMo-Plus (Li et al. 2026); drift-era peaks that don’t reproduce are excluded.

  • AGM belief revision: 49/49

    All seven postulates (K*2–K*6, Relevance, Core-Retainment) pass against the shipped engine. The compliance report is committed and public.

    Compliance report

  • Cited by AWS

    “Kumiho (Park, 2026) demonstrates the operational feasibility of these guarantees for agent memory” — AWS Generative AI Innovation Center, ICML 2026 RLxF Workshop paper.

    arXiv:2606.17591

  • Independently implemented

    Atlas, an open-source project, calls itself “the first publicly released implementation of Kumiho’s specification” — crediting the paper by name.

    RichSchefren/atlas

  • The formalism itself

    Graph-Native Cognitive Memory for AI Agents: formal belief revision semantics for versioned memory architectures.

    arXiv:2603.17244

The easiest way in is Kumiho Desktop.

One app installs Community Edition, connects to Kumiho Cloud, and adds plugins — and it stays local-first: your graph lives on your machine, the installer verifies checksums fail-closed, and nothing phones home. Cloud is a choice, not a requirement.

Kumiho Desktop

Download once. It sets up the server, connects your agents, installs plugins, and updates itself.

  • Installs Community Edition
  • Connects to Kumiho Cloud
  • Installs plugins in a click
Download Kumiho Desktop

Windows · macOS (Apple-signed) · Linux · auto-updating

Prefer the terminal? Install the server directly.

  1. Install Community Edition

    One command downloads the latest release, verifies its checksum, and launches the onboarding wizard.

    curl -fsSL https://kumiho.io/install | sh

  2. Start a local graph

    A local Neo4j 5 container is all the server needs. The wizard sets it up for you.

    handled by the wizard · manual alternative

    docker run -d --name kumiho-neo4j -p 7687:7687 -p 7474:7474 -e NEO4J_AUTH=neo4j/your-local-password neo4j:5

  3. Connect an agent

    One plugin install wires the MCP server, hooks, and skills for Claude Code. Other MCP clients: pip install kumiho-memory.

    claude plugin marketplace add KumihoIO/kumiho-plugins && claude plugin install kumiho-memory@kumiho-plugins
Full setup guide, including Windows

Built on a versioned provenance graph.

The same graph that powers agent memory started in production creative pipelines — immutable revisions, typed dependency edges, time-travel queries. Agent memory inherits that rigor; it isn’t a vector store with a marketing layer.

Kumiho Browser showing revision history and lineage for creative assets

Questions engineers actually ask

Does my agent’s data leave my machine?

Not with Community Edition — the server binds to loopback only and stores everything in your local Neo4j. Full conversations can stay local as markdown artifacts; if you opt into cloud, short structured summaries are what sync.

What happens when I switch LLM providers or models?

Nothing breaks. Memory is graph-resident and model-agnostic — history, provenance, and recall carry across provider and model changes.

How is this different from a vector database?

Kumiho stores versioned, typed graph nodes with provenance and dependency edges, and revises beliefs formally when facts change. Vector similarity is one retrieval mode, not the memory model.

Do I need Neo4j?

Yes — Community Edition uses a local Neo4j 5 as its graph store. It’s one docker command, and the onboarding wizard walks you through it (bring your own instance if you already run one).

What is Dream State?

Async consolidation that reviews memory in the background: enriching metadata, linking related items, and pruning noise — with safety guards so it never silently destroys history.

How do I integrate with my agent?

For Claude Code, one plugin install (kumiho-memory@kumiho-plugins) wires the MCP server, session hooks, and skills. Any other MCP client or the SDKs work too. Two reflexes cover the loop: engage (recall before responding) and reflect (capture after).

Can I start small?

Yes. One MCP connection or one folder is a complete starting point; expand only when it proves value.

Is the code open?

The SDKs and the benchmark harness are public on GitHub — including the AGM compliance suite you can run yourself. The Community Edition server is a free binary under an EULA.

Give your agents a memory you can audit.

One download — it installs Community Edition, connects Cloud, and adds plugins. Your machine, your graph.

Download Kumiho Desktop

Free · Windows / macOS / Linux · auto-updating

Prefer the terminal? Install the server directly.

curl -fsSL https://kumiho.io/install | sh
Read the paper
Kumiho — The Memory Layer AI Agents Can Trust