The published research
behind our agentic memory.

VEKTOR implements concepts from three peer-reviewed papers and one open research project. The implementation is entirely original. No code was copied. These papers shaped how we think about memory.

NOTE

All concepts explained here are derived from publicly available research. VEKTOR's source code is original and proprietary. Links go directly to the original papers.

Four Foundations
0%
Adjusted accuracy
LongMemEval benchmark
Long-context memory recall
0ms
Avg. recall latency
12× faster than cloud
Local SQLite · zero network hop
0%
Graph accuracy
Drift rate near zero
MAGMA graph engine
MAGMA Graph
4-layer memory architecture
Semantic
Causal
Temporal
Entity
BM25 + vector RRF dual-recall
0/31
Causal inference tests
All passing
G-formula · MSM · IV · RCA
Judge GPT-4o-mini
Build Slipstream v1.7.7
Metric Adjusted accuracy
BENCHMARK · JUN 22, 2026

81% accuracy on LongMemEval

Tested on 105 long-context memory recall questions with gpt-4o-mini judge. ONNX MiniLM-L6-v2 embedder. RRF dual-channel retrieval (vector + BM25).

Adjusted Accuracy
81.0%
LongMemEval Benchmark
105 questions tested
gpt-4o-mini judge
Avg. Recall Latency
28ms
12× Faster than Cloud
36 queries/second
Best Category
100%
Abstention (Unanswerable)
10/10 questions

Results by Question Type

Question Type
Accuracy
Count
Abstention
Correctly skipped unanswerable
100%
10/10
Single-session assistant
Assistant-only conversations
93.3%
14/15
Multi-session
Across multiple conversations
80.0%
16/20
Single-session user
User-only interactions
80.0%
16/20
Single-session preference
User preference recall
80.0%
8/10
Knowledge updates
Handling new/changed facts
73.3%
11/15
Temporal reasoning
Timeline and sequence questions
66.7%
10/15

Methodology

Dataset

LongMemEval v4 benchmark. 105 long-context memory questions across 7 categories.

Judge

gpt-4o-mini evaluates whether recalled context answers each question correctly.

Embedder

ONNX all-MiniLM-L6-v2. 384-dimensional semantic vectors. Local execution.

Backend

SQLite + pgvector. Identical accuracy on both. Same RRF retrieval algorithm.

Retrieval

RRF dual-channel fusion. Vector (pgvector HNSW) + BM25 keyword search ranked together.

Date

June 22, 2026. Validated with extended test harness. Production-ready.

Architecture
How VEKTOR works.

Four systems working together: the ingest pipeline that decides what to write, multi-signal retrieval that fuses three search channels, the MAGMA 4-layer graph, and the AUDN conflict resolution loop.

01 — Ingest pipeline

Every memory.store() call probes for related context, runs AUDN to decide the verdict, embeds and links entities, then writes to the graph. NO_OP skips the write entirely — graph stays lean.

Store call memory.store()
Context probe Find related nodes
AUDN verdict ADD / UPDATE / DELETE / NO_OP
Embed + link Vector + entity tag
MAGMA graph Semantic · Causal · Temporal · Entity
↩ NO_OP path — write skipped, graph unchanged
02 — Multi-signal retrieval

Three channels run in parallel and fuse results via Reciprocal Rank Fusion. BM25 is weighted 2× — keyword precision outperforms semantic alone for technical queries. Combined score beats any single channel.

Query
BM25 keyword
Porter stemming
2× weight
RRF fusion
Combined rank score
Semantic vector
Cosine similarity · HNSW
Entity graph
MAGMA edge traversal
Top-k results · ~28ms avg latency · <50ms p95 · three channels run in parallel
03 — MAGMA 4-layer graph

Four distinct memory layers, each answering a different question. Recall traverses all four simultaneously — entity, semantic, causal, and temporal signals combine into a ranked result that pure vector search cannot produce.

ENTITY
Who
Named entities, projects, people, concepts — co-occurrence links between them
SEMANTIC
What
Fact nodes, vector embeddings, cosine similarity clustering — the raw knowledge store
CAUSAL
Why
A caused B edges, decision chains, reasoning paths — enables multi-hop traversal
TEMPORAL
When
Ordered session history, validity windows, supersession chains — facts that change over time
Recall traverses all four layers simultaneously · fused via RRF · beats pure vector search on temporal and multi-hop queries
04 — AUDN conflict resolution

The AUDN loop fires before every write. Context probe finds the top-5 related nodes via BM25 + semantic search, then routes to the correct verdict. Four possible outcomes keep the graph accurate without any manual curation.

New memory memory.store()
Context probe BM25 + semantic · top-5
AUDN decision Route to verdict
ADD
Genuinely new information — write new node to graph
UPDATE
Supersedes existing node — invalidate old, write new
DELETE
Contradicts existing node — remove the conflict
NO_OP
Already stored at sufficient fidelity — skip write entirely
Fires on every memory.store() call · graph never accumulates contradictions or duplicates
Ecosystem
The full toolkit.

VEKTOR Slipstream is the memory core. Four tools in the ecosystem each solve a distinct layer of the agent infrastructure problem.

CLI · Apache 2.0

Cross-standard vector database migration and memory portability. Move your entire memory graph between any vector store in one command. Import Claude and ChatGPT conversation history with LLM fact extraction. Back up to any Git host with AES-256-GCM client-side encryption.

npm install -g @vektormemory/vex
  • Migrate between Pinecone, Qdrant, ChromaDB, Weaviate, pgvector, Redis, Milvus, Neo4j, and VEKTOR
  • Import Claude and ChatGPT conversation exports with automatic fact extraction via any LLM provider
  • Sign exports with BLAKE3 + Ed25519 for tamper-evident transfer between systems
  • Sovereign backup to GitHub, Codeberg, or self-hosted Gitea — AES-256-GCM, key never leaves your machine
  • Restore full memory on a new machine in under a minute with vex sync pull
github.com/Vektor-Memory/Vex →
vex migrate --from pinecone --to vektor
Move entire memory graph between stores
vex import --source claude --extract
Import Claude conversation history with LLM fact extraction
vex export --sign
Export and sign with BLAKE3 + Ed25519
vex sync
Encrypted sovereign backup to Git host
vex sync pull
Restore full memory on new machine
vex verify memories.vmig.jsonl
Verify export integrity against signature
CLI · Open Source

MCP configuration sync. One .mcp.json file. Every AI editor. Always in sync. Define your MCP servers once and push to Claude Desktop, Cursor, VS Code, Windsurf, Claude Code, Cline, Roo Code, Gemini CLI, GitHub Copilot, Continue, and Codex with one command.

npm install -g @vektormemory/vek-sync
  • Bootstrap from any existing editor with vek-sync init --from cursor — pulls your current config as the source of truth
  • Preview every change before it writes with --dry-run — see exactly what changes in each editor config
  • Verify servers are actually running with vek-sync ping — spawns each server and checks MCP handshake
  • Store secrets in a local AES-256-GCM vault, referenced as vault:key-name — never written to editor configs as plaintext
  • Share your config via URL with vek-sync share — secrets stripped before upload, teammates pull with one command
  • Detect drift between .mcp.json and installed editors with vek-sync diff — exits non-zero in CI
github.com/Vektor-Memory/Vek-Sync →
vek-sync init --from cursor
Bootstrap .mcp.json from existing editor
vek-sync sync --dry-run
Preview changes without writing anything
vek-sync sync
Push config to all installed editors
vek-sync ping
Verify each MCP server responds
vek-sync diff
Detect drift between config and editors
vek-sync vault set my-key sk-abc123
Store secret in local encrypted vault
CLI · v0.4.0

Universal AI tool integration layer. Self-improving prompt engine that learns from your codebase history. Every correction stored. Every success a reusable pattern. Works with Claude Code, Codex, Gemini CLI, Cursor, and Windsurf.

npm install -g @vektormemory/via
  • via prompt — generates historically-informed prompts with BM25 retrieval, AVOID store (30-task decay), task-type-aware token budgets, and git hook feedback capture
  • via memory — hybrid BM25 + VEKTOR semantic search, sync to VEKTOR, memory stats
  • via task — team kanban board backed by SQLite, share via a single Git-committed JSON file
  • via diff --live — stream two AI tools side by side in real time
  • via convert --batch — recursive folder conversion with progress bar, no upload
  • Export accumulated prompt intelligence to CLAUDE.md, YAML, Codex config, or Gemini TOML
github.com/Vektor-Memory/Via →
via prompt "add auth to the API"
Generate memory-enriched prompt with history
via prompt --learn success
Record outcome — improves next prompt
via prompt --avoid "never use Passport.js" --scope global
Add constraint injected into all future prompts
via prompt --export claude
Write learned patterns to CLAUDE.md
via task board
Show team kanban: OPEN / IN PROGRESS / DONE
via diff --live "explain X" --tools claude,openai
Stream two AI responses side by side
CLI · Apache 2.0

Cryptographic proof of what your code looked like, and when. Stamps proprietary headers into your source, snapshots the codebase into a Merkle-tree manifest bound to your git commit, and anchors that manifest with two independent timestamp authorities so no single authority is a point of failure.

npm install -g @vektormemory/prov
  • prov init — interactive wizard for owner, product, licence ID, and evidence folder, or pass flags for CI/scripted setup
  • prov stamp — insert proprietary headers into every source file, shebang-safe, with a CI-checkable --check mode
  • prov manifest — snapshot the codebase into a Merkle tree bound to the current git commit; prove a single file belongs to a snapshot without exposing the rest
  • prov timestamp — dual-anchored with RFC 3161 (FreeTSA) and OpenTimestamps (Bitcoin), so no single timestamping authority is a dependency
  • prov verify — re-checks file hashes, the Merkle root, and both timestamps
  • Evidence, not access control — pairs with a commercial licence/EULA rather than replacing one
github.com/Vektor-Memory/Provenance →
prov init
Interactive wizard — owner, product, licence ID
prov stamp add
Insert proprietary headers into every source file
prov stamp check
CI: exit 1 if any file is missing a header
prov manifest create
Snapshot codebase into a Merkle tree, bound to git commit
prov timestamp create
Anchor manifest with FreeTSA + OpenTimestamps
prov verify
Re-check file hashes, Merkle root, and both timestamps
Android · v1.0.4 · Free

Local-first note-taking app with persistent AI memory built in. Every note stored in the VEKTOR memory graph automatically. JOT Collab fires four seconds after you stop typing — surfaces an insight, a gap suggestion, and four arXiv papers from the literature, without leaving the editor.

Google Play — Download Free
  • Notes stored directly in your VEKTOR memory graph — recalled by your desktop agents automatically next session
  • BM25 + semantic search across all notes — finds what you meant, not just what you typed
  • JOT Collab: parallel LLM call returns insight, suggestion, and 4 arXiv papers via 4-level progressive fallback
  • Cross-session memory — start a new writing session on the same topic and it surfaces what you noticed last time
  • Export any note as structured markdown with APA citations
  • Build Medium-ready article drafts from your notes with one tap — 8-section structure from accumulated thoughts
Write → pause 4s → JOT fires
Auto-surfaces insight + arXiv papers without asking
Accept insight → stored in VEKTOR
Accepted insights flow into memory graph for future sessions
Export .md with APA citations
One tap — citations generated from sourced papers
Build article draft
8-section Medium structure from your notes and insights
Memory sync with desktop
Notes recalled by Claude Code and Cursor next session
Core Concepts
How the research maps to VEKTOR.
01 — GRAPH STRUCTURE

MAGMA 4-Layer Memory

Every piece of information is stored as a node in a typed, attributed graph. Semantic nodes capture facts. Causal nodes capture why. Temporal nodes track when. Entity nodes track who. Edges between them encode relationships, not just proximity.

02 — CURATION LOOP

AUDN — Autonomous Update

Before writing any memory, VEKTOR asks the model: does this already exist? Does it contradict something? Should it replace a previous belief? The AUDN decision (Add / Update / Delete / None) fires on every remember() call. The graph never accumulates stale data.

03 — CONSOLIDATION

REM Cycle — Dream Engine

Inspired by EverMemOS lifecycle management. While the agent idles, a 7-phase background process scans recent memories, identifies clusters, and compresses fragments into higher-level insights. The result: the graph grows wiser, not just larger. Available in VEKTOR Slipstream.

04 — RETRIEVAL

Associative Recall

Unlike keyword RAG, memory.recall() traverses the graph using vector similarity and edge weights together. A query doesn't just find matching text — it finds connected context: the reason something was remembered, the time it changed, and the entities involved.

05 — PERSISTENCE

Local-First SQLite

Pure SQLite. No cloud sync, no external API calls for memory operations. The graph lives in a single .db file on your server. Backup is a file copy. Migration is a file move. Memory never touches a third-party service — your agent data is yours.

06 — CONTEXT

Briefing — OS Resume

The MemGPT OS paradigm made practical. Each session begins with memory.briefing() — a structured summary of what the agent knew when it last ran. Topics reviewed, decisions made, open threads. The agent doesn't start from zero; it wakes up and continues.

Originality
Concepts are public. Implementation is ours.
No code was borrowed.

Every line in VEKTOR was written from scratch. The papers above shaped how we think about memory architecture — they are the intellectual foundation. But the implementation decisions: the SQLite schema, the AUDN prompt design, the REM phase sequence, the embedding pipeline — those are original VEKTOR engineering.

  • Open research — all four papers are publicly available and linked directly
  • Original schema — VEKTOR's graph structure is not a port of any reference implementation
  • No SDK reuse — we did not fork or extend any OSS memory library
  • Proprietary curation logic — the AUDN loop prompt chain is VEKTOR-specific
  • Independent REM design — the 7-phase dream engine is not based on EverMemOS code
Why it matters.

Publishing the research foundations lets you verify the concepts behind VEKTOR. If you're evaluating whether VEKTOR's approach is sound, read the papers. If you want to understand the implementation, full documentation is included with your purchase.

  • Peer-reviewed concepts — the architectural ideas have been validated outside VEKTOR
  • Auditable decisions — you can trace every design choice back to a research principle
  • Future-proof design — built on ideas that were peer-reviewed in 2025, not trend-chasing
  • Commercial licence — Vektor Slipstream includes commercial use rights
  • Sovereign framework — 8 laws govern how the system is built and how your data is handled. Four are enforced by the code. Four are design commitments. All are auditable. Read the laws →
Research foundations
Papers that shaped VEKTOR.
Graph Architecture
MAGMA
2601.03236
4-layer typed graph architecture. Informs VEKTOR's semantic, causal, temporal, and entity memory layers.
Used in memory.graph() · MAGMA layers
Memory Lifecycle
EverMemOS
2601.02163
Memory as an operating system with lifecycle phases. Informs the REM consolidation cycle.
Used in REM Cycle · memory.dream()
Deduplication
Mem0
2504.19413
Compression and conflict resolution for growing memory graphs. Informs the AUDN decision loop.
Used in AUDN loop · memory.store()
Agent OS
MemGPT / Letta
2310.08560
LLM as stateful OS with paged virtual memory. Informs the session briefing and resume system.
Used in memory.briefing() · session OS

Ready to build with VEKTOR?

From $9/month. Local-first. Drop into any Node.js agent in minutes.

Related
Vector memory for agentic systems — comparison → MAGMA architecture explained → RAG vs associative memory → How the REM cycle works → VEKTOR Slipstream SDK →