ArqonDB is an open-source agent memory database written in Rust, purpose-built for AI agents and LLM applications. It provides persistent, explainable, searchable memory through causal reasoning graphs, temporal graphs, HNSW vector search, and agent state branching — all unified on top of a distributed key-value store. It is Apache 2.0 licensed and supports Python, Rust, Go, Java, and C++ SDKs.

How fast is ArqonDB compared to RocksDB?

In-memory benchmarks (10K pairs): ArqonDB is 6.4x faster than RocksDB on sequential writes (5.29ms vs 33.99ms), 1.3x faster on batch writes (3.69ms vs 4.85ms), 2.3x faster on sequential reads (4.20ms vs 9.56ms), and 1.7x faster on random reads (5.40ms vs 9.01ms). Flush-to-SST benchmarks (100K pairs, 1KB values): ArqonDB is 4.4x faster on sequential write+flush (105.40ms vs 462.95ms), on par on batch write+flush (89.92ms vs 88.44ms), and 1.3x faster on point reads after flush (113.18ms vs 151.99ms). ArqonDB achieves this through write group batching and a unified Raft WAL design.

What is a Causal Graph in ArqonDB?

The Causal Graph in ArqonDB records AI agent reasoning as a directed acyclic graph (DAG). Each node is a step with one of five types: Observe, Think, Act, Tool, or Result. Edges between steps are semantically typed as Triggers, Informs, Branches, or Merges. The graph supports full BFS traversal in forward, backward, or both directions for complete explainability and audit trails.

What is a Temporal Graph in ArqonDB?

The Temporal Graph in ArqonDB extends causal edges with validity intervals [valid_from, valid_to]. You can query the graph at any point in time using traverse_at(), traverse only edges active within a time window using traverse_in_window(), expire edges without deletion using expire_edge(), and retrieve the full version history of any edge using edge_history(). This enables time-aware reasoning and historical analysis.

What languages and protocols does ArqonDB support?

ArqonDB provides official gRPC SDKs for Python (3.9+), Rust (1.70+), Go (1.21+), Java (17+), and C++ (17+). It also natively supports the Redis RESP2 protocol, so any existing Redis client (redis-cli, Python redis, Node.js ioredis, etc.) can connect directly to ArqonDB on port 6379.

How does ArqonDB handle agent state branching?

ArqonDB provides lightweight fork/merge primitives with copy-on-write overlays. Agents can fork a branch from any point in their reasoning timeline to explore alternative strategies without duplicating data. Branch reads walk the parent chain transparently. Winning branches can be atomically merged back to the main timeline, while losing branches can be discarded.

How is ArqonDB deployed?

ArqonDB can be deployed in multiple ways: single-node for development (cargo run), Docker containers with multi-stage builds, Kubernetes with StatefulSets for production clusters (3+ data nodes), or macOS launchd for background services. The three-tier architecture consists of a stateless Gateway, a Metadata Raft group, and sharded Data Nodes.

What is the AgentStateService in ArqonDB?

The AgentStateService is ArqonDB's core API for agent memory management. It provides causal graph operations (add_step, add_edge, traverse), temporal edge queries (traverse_at, edge_history), state branching (fork, merge_branch), reactive watches (cas_put, watch_prefix), and vector similarity search (find_similar_chains). A production demo (Arqon) uses AgentStateService to power an end-to-end quantitative trading agent with full causal traceability across market data ingestion, AI signal generation, and trade execution.

Is ArqonDB open source?

Yes, ArqonDB is fully open source under the Apache 2.0 license. The source code is available on GitHub at github.com/AlbericByte/ArqonDB. The project has 920+ tests, 64,000+ lines of Rust code, and 132+ pull requests merged.

ArqonDB - Agent Memory Database | Causal Graph + Temporal Graph + Vector Search + Distributed KV

Name: ArqonDB
Availability: InStock
Author: AlbericByte

ArqonDB - Agent Memory Database for AI AgentsArqonDB is an open-source agent memory database written in Rust. Give your AI agents persistent, explainable, searchable memory with causal graphs, temporal graphs, vector search, state branching, and distributed KV storage.Agent Memory Features

Distributed Key-Value Store - Sharded KV with gRPC API. Put, Get, Delete, Scan, BatchWrite across a distributed cluster.

LSM-Tree Storage Engine - Concurrent skip-list MemTable, prefix-compressed SST files, bloom filters, sharded LRU block cache, leveled compaction.

HNSW Vector Similarity Search - Built-in HNSW index with L2, cosine, and inner-product distance. Product Quantization (PQ) and Scalar Quantization (SQ) for large-scale.

Causal Reasoning Graph - DAG-based agent reasoning trace. Step types: Observe, Think, Act, Tool, Result. Edge types: Triggers, Informs, Branches, Merges. Full BFS traversal.

Temporal Graph - Time-aware edges with validity intervals [valid_from, valid_to]. Point-in-time traversal, range queries, edge expiration, and version history.

Agent State Fork & Branch - Lightweight branching with copy-on-write overlays. Explore alternate reasoning paths. Atomic merge back.

Raft Distributed Consensus - Single-threaded event loop. Separate metadata and data plane Raft groups.

Redis Protocol Compatible - RESP2-compatible TCP server. Any Redis client can connect directly.

Reactive State - Compare-and-swap with optimistic locking. Watch key prefixes for real-time gRPC notifications.

Multi-Language SDKs - Official gRPC clients for Python 3.9+, Rust 1.70+, Go 1.21+, Java 17+, and C++ 17+.

Management Web Console - Dashboard with cluster stats, shard topology, KV terminal, user management, Prometheus metrics.

ArchitectureThree-tier distributed architecture: stateless Gateway (gRPC :9379, HTTP :9380, Redis :6379) routing to a Metadata Plane (Raft consensus for shard map, column families, node registry) and Data Plane (ShardEngine per node with LSM-tree, HNSW vector index, agent state column families, per-shard Raft). Storage engine components: WAL with CRC32 checksums, MemTable with skip-list MVCC, SST files with bloom filters and compression (Zstd, Snappy, LZ4), sharded LRU block cache, leveled k-way merge compaction.Performance vs RocksDBIn-Memory (10K pairs, 20B keys, 100B values, WAL enabled)

Sequential Write: ArqonDB 5.29ms vs RocksDB 33.99ms — 6.4x faster

Batch Write (100/batch): ArqonDB 3.69ms vs RocksDB 4.85ms — 1.3x faster

Sequential Read: ArqonDB 4.20ms vs RocksDB 9.56ms — 2.3x faster

Random Read: ArqonDB 5.40ms vs RocksDB 9.01ms — 1.7x faster

Flush-to-SST (100K pairs, 20B keys, 1KB values, 4MB write buffer)

Sequential Write + Flush: ArqonDB 105.40ms vs RocksDB 462.95ms — 4.4x faster

Batch Write + Flush: ArqonDB 89.92ms vs RocksDB 88.44ms — on par

Point Read After Flush: ArqonDB 113.18ms vs RocksDB 151.99ms — 1.3x faster

920+ tests, 64,000+ lines of Rust, 132+ PRs merged.AgentStateService - Core Agent Memory APIThe AgentStateService provides purpose-built primitives for AI agent memory: Causal Graph records reasoning traces as DAGs with Observe/Think/Act/Tool/Result steps and Triggers/Informs/Branches/Merges edges. Temporal Graph adds time-aware edges with validity intervals, point-in-time traversal (traverse_at), range queries (traverse_in_window), edge expiration, and version history (edge_history). Fork & Branch enables lightweight state branching with copy-on-write overlays for exploring alternate reasoning paths. Reactive State provides CAS writes and prefix watch notifications. Similarity Search uses find_similar_chains for KNN on reasoning step embeddings to let agents learn from past experience.Demo: Quantitative Trading Agent powered by AgentStateServiceA production demo (Arqon) showcases ArqonDB's agent memory capabilities in a quantitative trading pipeline. The AgentStateService records the full agent lifecycle: (1) Observe steps for market data ingestion across 6,800+ NASDAQ symbols and news sentiment analysis; (2) Think steps for AI signal generation using 200+ technical indicators and 10,000+ alpha factors; (3) Similarity search on 64-dimensional pattern vectors to find historically similar market conditions; (4) Act steps for trade execution planning; (5) Result steps for portfolio tracking; (6) Fork branches for exploring alternative trading strategies. The causal graph provides complete audit trails and explainability.SDKs & ProtocolsOfficial gRPC clients: Python 3.9+, Rust 1.70+, Go 1.21+, Java 17+, C++ 17+. Redis RESP2 protocol compatible — connect with redis-cli or any Redis client library.DeploymentSingle Node (cargo run), Docker (multi-stage build), Kubernetes (StatefulSet with 3+ data nodes), macOS launchd.Open source, Apache 2.0 licensed. View on GitHub.