...
[Comparison ยท as of October 19, 2026]

OpenViking vs Honcho

OpenViking, from ByteDance's Volcano Engine, is a context database: one virtual filesystem where an agent keeps documents, code, skills, and memories, and browses them with ls, read, and find. Honcho is a memory layer for people and agents: it reasons over conversations into a representation of each participant and answers questions about them. Both are AGPL-3.0, both self-host, and both are Hermes memory providers.

How memory gets built
OpenViking
Extracts memories when a session is committed
Honcho
Reasons over messages into conclusions
What you pay for
OpenViking
Free to self-host. Managed prices not in English
Honcho
$2.00 per million tokens ingested
Open source
OpenViking
AGPL-3.0 core
Honcho
AGPL-3.0
Self-hosting
OpenViking
Needs embedding and vision-language models
Honcho
Same code as the hosted service
[Summary]

OpenViking or Honcho: the short answer

choose OpenViking if

Choose OpenViking if

  1. 01You want documents, code repos, skills, and memory in one store, with retrieval over imported resources.
  2. 02You want memory as Markdown files you can open, edit, and diff.
  3. 03You build on Volcengine and Doubao models, or need a managed service in China.
choose Honcho if

Choose Honcho if

  1. 01Your agent needs to know what each user wants and how that changes.
  2. 02You want a plain-language answer about a user.
  3. 03You want published pricing and a managed service outside China.
[Mechanism]

How memory gets built

OpenViking
write01You commit a session
02An LLM summarizes it
03Typed memories as Markdown files
read04One vector search per query
05Scoped by directory, type, and permissions
06Ranked file URIs at L0, L1, or L2
Honcho
write01Each message, stored as sent
02The deriver reasons over it in the background
03Conclusions about each peer
read04session.context()
05Representation, summary, and recent messages
06Inside your token budget, in about 200ms

Each step restates the vendor's own docs, listed under Sources.

[Comparison table]

OpenViking and Honcho, row by row

What it isOpenViking
An "open-source context database for AI agents": one virtual filesystem for knowledge, memory, and skills, by ByteDance's Volcano Engine
Honcho
An open-source memory layer for the agents and apps you already run
How memory gets builtOpenViking
Extracts memories when a session is committed
You commit a session. In the background an LLM summarizes it and extracts typed memories (profile, preferences, entities, events, cases) as Markdown files, with a diff log
Honcho
Reasons over messages into conclusions
Stores each message as sent. A background deriver reasons over new messages and writes conclusions about each participant; dreaming consolidates them later
Whose memory it keepsOpenViking
Account, user, then peer namespace
Account, then user, then an optional peer namespace under viking://user/{id}/peers/
Honcho
Peers: users, agents, and groups
Peers: any user, agent, or group, plus each peer's view of the others
What a query returnsOpenViking
Ranked file URIs at L0, L1, or L2
Ranked file URIs with a one-line abstract, an overview, or the complete file (L0, L1, L2), grouped into memories, resources, and skills
Honcho
context() in about 200ms, or chat()
context() returns a representation, a summary, and recent messages inside a token budget you set, in about 200ms. chat() answers a plain-language question about a peer
What you pay forOpenViking
Free to self-host. Managed prices not in English
Self-hosting is free. Volcengine's managed OpenViking is billed per database, with personal and enterprise plans, in the Beijing region. Prices not published in English
Honcho
$2.00 per million tokens ingested
$2.00 per million tokens ingested. Reading context is unlimited. chat() queries cost $0.001 to $0.50 each, by reasoning level
Open sourceOpenViking
AGPL-3.0 core
Core AGPL-3.0 (Apache-2.0 until March 2026). CLI and examples Apache-2.0. The README adds terms on rewriting and translating the project
Honcho
AGPL-3.0
Server and SDKs, AGPL-3.0
Self-hostingOpenViking
Needs embedding and vision-language models
uv tool install openviking && openviking-server init. Needs an embedding model and a vision-language model. Docker also available
Honcho
Same code as the hosted service
honcho start --setup runs the API, Postgres, and Redis on Docker, plus an LLM key. The hosted service runs the same code
Works withOpenViking
Claude Code, Codex, Cursor, OpenClaw (as a context engine), Hermes, OpenCode, pi, DeerFlow, LangChain, LangGraph, and MCP clients
Honcho
Plugins for Claude Code, Codex, OpenCode, Hermes Agent, OpenClaw, Kilo Code, Pi, and DeepSeek Harness. A hosted MCP server for other clients. Guides for the Vercel AI SDK, LangGraph, CrewAI, and n8n
Published benchmarksOpenViking
LoCoMo inside each harness, against its native memory: OpenClaw 82.1, Hermes 82.9, Claude Code 80.3. Self-reported, on Doubao models
Honcho
LongMemEval S 90.4, LoCoMo 89.9, BEAM 1M 61.8 and 10M 40.9. Self-reported, with configs and raw outputs on GitHub

As of October 19, 2026. Benchmark scores are each vendor's own, from separate runs, and aren't directly comparable.

[OpenViking]

OpenViking keeps context as files and extracts memories when a session is committed

Everything in OpenViking lives under a viking:// filesystem: resources/ for documents and repos, user/{id}/memories/, skills/, and peers/. Agents navigate it with ls, tree, read, grep, and find. Each directory gets a generated one-line abstract (L0) and an overview (L1), and the complete file (L2) loads on demand (README).

Memory comes from committing a session. OpenViking archives it, then an LLM writes a summary and extracts typed memories as editable Markdown files, logging each change to memory_diff.json (session docs). In Hermes, the plugin commits at 20,000 pending tokens and at the end of a session.

Retrieval runs one vector search per query, scoped by directory, type, and permissions, with optional reranking. The retrieval docs say it "does not navigate directories recursively".

[Honcho]

Honcho reasons over every message into a model of each peer

Honcho stores each message as it was sent, labelled with the peer who said it. A peer is any participant: a person or an agent. A background process called the deriver reasons over new messages and writes conclusions about each peer, including things that follow from what was said but were never stated outright. When a user corrects a fact, the deriver writes a new conclusion with a timestamp, and the old one stays for now. Dreaming runs later, once enough new conclusions have built up, deletes conclusions a newer fact has replaced, and merges ones that say the same thing.

Your agent reads memory two ways. session.context() returns the representation, a summary, and recent messages inside a token budget, in about 200 milliseconds, and those reads are unlimited. peer.chat() takes a question and reasons over the representation to answer it, at one of five levels from minimal to max, priced per query from $0.001 to $0.50.

Writes are asynchronous. A conclusion lands after the deriver runs, in time for the next turn but not the same one. Each peer can also keep its own view of every other peer it has observed. A support agent's model of a customer and the customer's model of that agent are separate objects.

[Where OpenViking fits better]

Pick OpenViking for documents and memory in one store, or memory you can edit as files

OpenViking is a broader store than Honcho. If your agent needs retrieval over documents and code repos as well as memory, OpenViking keeps them in one place. Honcho stores conversations and what they reveal about the people and agents in them.

OpenViking stores memory as Markdown files. You can open what it extracted, edit it, and see each change in a diff log. Honcho's conclusions are available through the API, and Honcho doesn't have a UI for browsing them yet.

It's multi-tenant out of the box when self-hosted, with accounts, users, roles, and per-file permissions.

[Why Honcho]

Honcho models the people your agent talks to

Honcho reasons over conversations into a representation of each person and agent, and chat() tells you about any of them in plain language. Honcho Cloud publishes its pricing: $2 per million tokens ingested, with context reads unlimited. chat() queries are priced per call.

[Questions]

FAQ

01Is OpenViking memory or RAG?+

Both. It stores imported documents and code alongside memories extracted from sessions, and retrieves across them. Honcho focuses on memory of people and agents from their conversations; for document retrieval you'd pair it with your own RAG.

02Which should I use as my Hermes memory provider?+

Hermes runs one external provider at a time and lists both in its memory provider docs. Pick OpenViking if you want Hermes to search your files and docs too. Pick Honcho if you want Hermes to learn who you are over time and share that across your other agents.

03Both are AGPL-3.0. What does that mean for a product?+

You can modify either and run it as a service, and if you do, you publish your changes. OpenViking's README adds its own terms about rewriting and translating the project. Using Honcho Cloud carries no AGPL obligation.

04Can I use OpenViking's managed service outside China?+

Volcengine's managed OpenViking is documented for the Beijing region and requires real-name verification (Volcengine docs). Outside China, the practical option is self-hosting.

05Are the LoCoMo numbers comparable?+

No. OpenViking reports LoCoMo inside each harness against that harness's native memory, on Doubao models (benchmark post). Honcho's 89.9 uses a different setup and judge (evals). Both are self-reported.