# recall vs OpenViking

OpenViking, from ByteDance's Volcengine, is a context database for agents: knowledge, memory and skills in one filesystem-like tree, with a model writing an abstract and an overview for every node. recall reads the chats Claude Code, Codex and Cursor already keep, indexes them with no model calls, and writes notes overnight with a model you choose.

Checked 17 Oct 2026 · recall 0.5.1 · [OpenViking on GitHub](https://github.com/volcengine/OpenViking)

## At a glance

OpenViking wants to be the one place an agent keeps everything: knowledge, memory and skills in a tree it walks like a filesystem, every node summarised at two levels so it reads as little as it needs. recall wants only to be the memory of your coding work: the chats Claude Code, Codex and Cursor already keep, indexed without a model and searched in milliseconds, with a few notes a night on top.

Both install into the same three agents through hooks and MCP. What they do with your sessions is very different.

| | recall | OpenViking |
| --- | --- | --- |
| Runs | On your machine | Self-hosted, or Volcengine's service in Beijing |
| Licence | MIT | AGPL-3.0, with added README terms; CLI Apache 2.0 |
| Model calls to store a chat | **0** | **A VLM call per node**, an LLM pass per committed session |
| A search takes | **11 ms** local, 47 with embeddings | No figure published; ingest is the slow part |
| Price | **Free** | Free to self-host; hosted plans unpriced, 50 files free |
| Chat text leaves your machine | **No**, with a local model | **Yes**: to the VLM and LLM, Volcengine's by recommendation |
| Claude Code, Codex, Cursor | MCP, skill, session hook | Hooks and MCP for Claude Code, Codex, Cursor, TRAE |

## Where both were measured

On SWE-ContextBench, OpenViking matched the past fix in its top three 51.5% of the time, after $18.96 and 570 minutes of model calls to take in the 300 sessions, the most of any system in the paper by far. recall 0.5.1 finds it 76.8% at the same cutoff and 79.8% in its top five, with no model calls. The paper does not define its metric, so read the gap loosely; the ingest bill is not loose.

The paper's end-to-end results are closer: with OpenViking's context the agent resolved 29.2% of tasks against 26.3% with none, and ran the fastest and cheapest per task. recall was not in that arm. On its own agent runs, Claude Haiku 5.5 using recall names the past fix for 87% of held-out issues, taking in about 7.8k tokens a question.

**Fig 1. recall 0.5.1 and OpenViking** SWE-ContextBench Lite: the past fix over all 300 sessions, and what it cost to take the sessions in.

| Measure | System | Figure | Note |
| --- | --- | --- | --- |
| Past fix in the top 3 | recall 0.5.1 | 76.8% | hybrid search, no model calls |
| Past fix in the top 3 | OpenViking | 51.5% | the paper's run: $18.96 and 570 minutes of model calls to take in the sessions |
| Model calls to take in the 300 sessions | OpenViking | $18.96 | 570 minutes |
| Model calls to take in the 300 sessions | LangMem | $0.98 | 58 minutes |
| Model calls to take in the 300 sessions | Mem0 | $0.24 | 21 minutes |
| Model calls to take in the 300 sessions | recall 0.5.1 | $0 | no model calls: a local full-text index, plus an optional local embedding model |

SWE-ContextBench Lite, 99 issues, 300 sessions · ingest costs as the paper reports them OpenViking's figure is the paper's run of a metric it does not define, and the paper does not say what it was asked. recall: hybrid search, one run. Mem0 and LangMem are the paper's other ingest costs, for scale.

## Cost

OpenViking's cost is a model for every node: a vision-language model writes each node's abstract and overview as it is ingested, and an LLM deduplicates and extracts memory when a session is committed. On SWE-ContextBench that came to $18.96 and nine and a half hours for 300 sessions. The software is free; the hosted service publishes no prices beyond 50 free files.

recall spends nothing to index or search: 300 sessions are seconds of local indexing. The nightly notes are its one model cost, with a model you choose: nothing with a local one, covered by a subscription, batch prices on an API key.

| | recall | OpenViking |
| --- | --- | --- |
| Model calls to store a chat | **0** | **A VLM call per node**, an LLM pass per committed session |
| Price | **Free** | Free to self-host; hosted plans unpriced, 50 files free |
| To take in 300 sessions | **$0**, no model calls | **$18.96**, 570 min of model calls |
| Cost of memory | One nightly run, your model | Model calls per node and per session |

## Latency

OpenViking publishes no retrieval latency; its tiered loading is designed to cut what the agent reads, and the paper's task runs were the fastest in the set. Ingest is the slow part: 570 minutes for 300 sessions, with a model call per node.

recall's search is a local index at 11 ms on ~2,800 chats, 47 ms with the optional embedding model, and indexing a new chat is a parse, not a model call.

| | recall | OpenViking |
| --- | --- | --- |
| A search takes | **11 ms** local, 47 with embeddings | No figure published; ingest is the slow part |
| Wait at write time | **None**: reads saved chats | A VLM summary per node; LLM dedupe at commit |

## Privacy

Self-hosted OpenViking keeps the tree on your machine but sends every node to the VLM and every committed session to the LLM you configured, and the recommended models are Volcengine's Doubao, hosted. The hosted service runs in Beijing, with non-China hosting planned, and publishes no data-residency statement. The core is AGPL, with the README adding terms on rewrites and translations.

recall is MIT and runs on your machine. It reads chats read-only, redacts secrets before indexing, sends no telemetry, and makes no network calls except to the model you chose for the nightly notes. With a local model, nothing leaves.

| | recall | OpenViking |
| --- | --- | --- |
| Runs | On your machine | Self-hosted, or Volcengine's service in Beijing |
| Licence | MIT | AGPL-3.0, with added README terms; CLI Apache 2.0 |
| Chat text leaves your machine | **No**, with a local model | **Yes**: to the VLM and LLM, Volcengine's by recommendation |
| Compliance | Nothing to certify: no service | No data-residency statement |
| Telemetry | **None** | Not stated |

## How memory is built

OpenViking's memory is a tree: sessions and documents become nodes under `viking://`, each with a model-written abstract and overview above its full content, and memory extracted at commit time filed in six categories. An agent walks it with filesystem commands and loads tiers as it goes.

recall's memory is an index and a folder of notes. The index holds every chat whole, ranked five ways and fused, so the agent searches rather than walks. The notes are markdown in git, each with a quote from its chat, consolidated rule by rule once a night. Loaded at session start, notes written by Claude Haiku 5.5 lift an agent from 32% to 75% on long MemoryCode histories.

| | recall | OpenViking |
| --- | --- | --- |
| Captured by | Reading the agents' own chat files | Hooks sending sessions into the tree |
| Memory is | Markdown notes in git, plus an index of every chat | A tiered tree: abstract, overview, full data |
| Retrieval | Full-text index, five rankings fused; optional local embeddings | Walking the tree; a vector index over references |
| You can edit it | **Yes**, and the edit wins | In the tree |

## Which to pick

**Pick OpenViking if**

- You want knowledge, memory and skills in one tree an agent can walk, with tiered summaries, and are already on Volcengine.
- You can afford a model call per node and the hours of ingest that come with it.
- AGPL and the README's added terms are fine for how you will run it.

**Pick recall if**

- You want your coding agents to remember with no model calls to index or search, and no hours of ingest.
- You want the past fix found more often on real issues, at zero ingest cost.
- You want MIT, your data on your machine, and memory you can read and revert.

## Questions

**Is OpenViking open source?**

The core is AGPL-3.0, with Apache 2.0 for the CLI crate and examples, and the README adds conditions against wholesale rewrites and unauthorised translations. The hosted service and the licence-key edition are commercial. recall is MIT.

**Why did OpenViking cost $18.96 to ingest 300 sessions?**

Because a vision-language model writes an abstract and an overview for every node in its tree, and an LLM extracts memory at every session commit. The benchmark's paper measured 570 minutes and $18.96 for the 300 sessions of SWE-ContextBench Lite. recall indexes the same sessions with no model calls.

**Which found the past fix more often?**

On SWE-ContextBench, OpenViking matched it in its top three 51.5% of the time in the benchmark's paper; recall finds it 76.8% at the same cutoff and 79.8% in its top five. The paper does not define the metric, so compare loosely.

**Do both work with Claude Code, Codex and Cursor?**

Yes, and in a similar way: hooks plus an MCP server. OpenViking's hooks send sessions into its tree for the model to summarise; recall's hooks load your notes at session start, and its indexer reads the transcripts the agents already write.

## Sources

- OpenViking on GitHub: https://github.com/volcengine/OpenViking
- OpenViking: architecture: https://mintlify.wiki/volcengine/OpenViking/concepts/architecture
- OpenViking on PyPI: https://pypi.org/project/openviking/
- SWE-ContextBench, Zhu et al.: https://arxiv.org/abs/2602.08316
- recall's benchmarks and method: https://github.com/alirng/recall/blob/main/docs/benchmarks.md