OpenViking: The Open-Source Context Database With 30,000+ GitHub Stars That Gives AI Agents Persistent Memory

If you've ever worked with an AI coding agent on a multi-session project, you've hit the same wall: the agent forgets everything. Every conversation starts from scratch, context gets lost, and you spend half your time re-explaining what you already told it yesterday. This is the memory problem — and it's the single biggest bottleneck in AI agent development right now.

OpenViking solves this with a radically different approach. Instead of bolting on yet another vector store, it treats agent context like a database — a virtual filesystem where memories, resources, and skills each live under a viking:// URI. Your agent browses its own context the way a developer browses files: with ls, tree, and find. No black-box retrieval, no guesswork.

Created by Volcengine (ByteDance's cloud infrastructure arm) and backed by research accepted at VLDB 2026, OpenViking has exploded to over 30,000 GitHub stars and 2,300+ forks since its launch in early 2026. Let's break down why.

The Problem: Why AI Agents Keep Forgetting Everything

Most AI agent frameworks treat context as a one-shot affair. You send a prompt, the model responds, and the context window fills up. When the conversation gets long, older messages get summarized or dropped entirely. The result:

• Context drift: The agent loses track of earlier decisions and preferences
• Token waste: Redundant re-explanations eat into your context budget
• No learning curve: Every session starts at zero, even with the same user
• Opaque retrieval: When a vector store returns the wrong chunk, you can't see why

Traditional solutions — RAG pipelines, vector databases, memory modules — each solve one piece of the puzzle. But they're disconnected. Your agent's knowledge about the user lives in one system, project documentation in another, and learned skills somewhere else entirely. OpenViking's insight is that all of this is just context, and context deserves a proper database.

How OpenViking Works: The Viking URI Protocol

OpenViking introduces the viking:// protocol — a URI scheme that organizes all agent context into a virtual filesystem. Think of it as a file explorer for your agent's brain:

viking://
├── resources/           # Project docs, repos, web pages
│   └── my_project/
│       ├── docs/
│       │   ├── api/
│       │   └── tutorials/
│       └── src/
└── user/
    └── {user_id}/
        ├── memories/    # Preferences, habits, experiences
        │   └── preferences/
        │       ├── writing_style
        │       └── coding_habits
        ├── resources/   # User-specific project files
        ├── skills/      # Learned capabilities
        │   ├── search_code
        │   └── analyze_data
        └── peers/       # Multi-agent shared context

Every piece of context has a deterministic address. When your agent needs to recall something, it navigates this tree — not by running a fuzzy similarity search, but by knowing exactly where to look. This is a fundamental shift from the "embed everything and hope for the best" approach.

Three-Tier Loading: L0, L1, L2

The real innovation is how OpenViking manages what to load and when. Every entry is processed into three layers on write:

• L0 (Abstract): A one-sentence summary (~100 tokens). Used for quick relevance checks. "Does this directory contain what I need?"
• L1 (Overview): Core information and structure (~2,000 tokens). Enough for planning without reading every detail.
• L2 (Details): The full original content. Only loaded when the agent actually needs it.

viking://resources/my_project/
├── .abstract    # L0: ~100 tokens - quick relevance check
├── .overview    # L1: ~2k tokens - structure and key points
└── docs/
    ├── .abstract
    ├── .overview
    └── api/
        ├── auth.md       # L2: full content, loaded on demand
        └── endpoints.md

This means your agent can scan hundreds of context entries using only L0 abstracts (a few hundred tokens total), drill into relevant directories with L1 overviews, and only read full L2 content when it's actually needed. The result: massive token savings with no loss of information.

Benchmark Results: 80–83% Accuracy With Up to 91% Fewer Tokens

OpenViking has been rigorously evaluated on two major benchmarks:

LoCoMo (Long-Context Memory)

This benchmark tests whether an agent can remember user preferences and facts across long conversations. Results with OpenViking:

• 80–83% accuracy across three different agent integrations (up from 24–57% with native memory systems)
• 34–91% reduction in input tokens
• 58–66% reduction in query latency

tau2-bench (Multi-Turn Agent Tasks)

This benchmark evaluates real-world agent tasks like retail order processing and airline bookings:

• +6.87 percentage points improvement in task success for retail scenarios
• +11.87 percentage points improvement for airline scenarios
• All improvements come from experience memory — the agent remembering what worked before

These numbers are significant because they show OpenViking isn't just a storage layer — it actively makes agents smarter over time by learning from past interactions.

Real-World Example: Building a Persistent Coding Assistant

Let's walk through a practical scenario. You're using Claude Code with OpenViking to work on a Python API project:

# Install and start OpenViking
pip install openviking --upgrade
openviking-server init  # Interactive setup wizard
openviking-server       # Start the server

# Add your project as a resource
ov add-resource https://github.com/your-org/your-api --wait

# Explore what OpenViking indexed
ov ls viking://resources/your-org/your-api
ov tree viking://resources/your-org/your-api/src -L 2

# Search for specific context
ov find "authentication middleware implementation"
ov grep "JWT token validation" --uri viking://resources/your-org/your-api/src

Now when you ask your AI agent, "How does our auth middleware handle expired tokens?" — it doesn't need to re-read your entire codebase. OpenViking's directory recursive retrieval first locates the highest-scoring directory using vector search, then drills down layer by layer. The result arrives with its surrounding context intact, and the entire retrieval trajectory is observable and debuggable.

After your session ends, OpenViking automatically extracts and stores:

• Your coding preferences (naming conventions, error handling patterns)
• Agent experience (what retrieval paths worked well)
• Project-specific knowledge (architecture decisions, team conventions)

Next session, your agent starts with all of this context already loaded — at L0/L1 granularity. No re-explanations needed.

Key Benefits of OpenViking

• Unified context storage: Memories, resources, and skills in one filesystem — no more juggling multiple databases
• Deterministic retrieval: viking:// URIs mean your agent always knows where to look, unlike opaque vector search
• Massive token savings: Three-tier loading cuts input tokens by 34–91% without losing information
• Observable debugging: Every retrieval leaves a trajectory you can inspect — see exactly which path produced each result
• Automatic session memory: User preferences and agent experiences are extracted and stored after each session
• Wide integration support: Works with Claude Code, Codex, OpenClaw, Cursor, Trae, LangChain, and 10+ other tools
• Open source under AGPLv3: No feature gates, no account required, fully self-hostable

Getting Started in 5 Minutes

# Requires Python 3.10+
pip install openviking --upgrade

# Interactive setup: choose your LLM provider and models
openviking-server init

# Validate your configuration
openviking-server doctor

# Start the server
openviking-server

The init wizard supports Volcengine, OpenAI, Codex OAuth, Kimi, GLM, and local Ollama — for Ollama, it can even detect your hardware and pull appropriate models automatically.

Want to try before installing? Head to OpenViking Studio — a live hosted playground with semantic search, context browsing, and a multi-agent hub. No installation required.

Frequently Asked Questions

1. What is OpenViking and how does it differ from a regular vector database?

OpenViking is a context database specifically designed for AI agents. Unlike a standard vector database that only does similarity search, OpenViking organizes all context (memories, resources, skills) into a virtual filesystem with the viking:// URI protocol. It uses three-tier loading (abstract, overview, details) to minimize token usage and provides deterministic, navigable context retrieval rather than opaque similarity matching.

2. Which AI coding tools does OpenViking integrate with?

OpenViking has official integrations with Claude Code, OpenAI Codex, OpenClaw, Cursor, Trae/TraeCode CLI, OpenCode, Hermes Agent, and Pi. It also supports LangChain/LangGraph, MCP (Model Context Protocol) clients, and a generic Agent Plugins system. Most integrations are one-click setup through the CLI or admin panel.

3. Is OpenViking free to use? What's the license?

Yes, OpenViking is fully open source under the AGPLv3 license. There are no feature gates, no account requirements, and no activation keys. The open-source edition includes everything you need for personal and production use. Volcengine also offers hosted SaaS and enterprise self-hosted editions for teams that prefer managed infrastructure.

4. How much token savings can I expect with OpenViking?

Based on the LoCoMo benchmark results, OpenViking reduces input token consumption by 34.3% to 91.0% depending on the agent integration and use case. The three-tier loading system means your agent only loads the detail level it actually needs — L0 abstracts for scanning (~100 tokens), L1 overviews for planning (~2,000 tokens), and L2 full content only when required.

5. Can OpenViking work with local LLMs like Ollama?

Absolutely. During openviking-server init, you can select Ollama as your provider. OpenViking will detect your available hardware, suggest appropriate models, and can even install the Ollama runtime and pull models for you. It works equally well with cloud providers like OpenAI, Volcengine, and Kimi.

6. What is the VikingMem paper and how does it relate to OpenViking?

VikingMem ("A Memory Base Management System for Stateful LLM-based Applications") is the research paper behind OpenViking, authored by researchers at ByteDance. It was accepted at VLDB 2026, one of the top database conferences. OpenViking is the open-source implementation of the core capabilities described in the paper (arXiv:2605.29640).

7. How does OpenViking handle multi-agent scenarios?

OpenViking's filesystem includes a peers/ directory under each user's context tree, enabling multi-agent shared context. Combined with the VikingBot agent framework (included in the open-source distribution), multiple agents can share and build upon a common knowledge base while maintaining their own specialized memories and skills.