Skip to content

The memory engine for agents and robots

An open-source memory runtime for persistent state, semantic retrieval, and knowledge. Run it embedded locally, deploy on edge robots, or self-host in your private cluster.

Embed with One Line
Available across TypeScript, Python, Rust, Go, and C++
MIT Licensed
// zero config; auto-provisions on first run
import clawdb from '@clawdb/sdk';

const db = await clawdb();

await db.memory.remember('User prefers dark theme and Python for backend APIs.');
const hits = await db.memory.search('tech preferences');
// score: 0.97 · hybrid HNSW+FTS5 · 4ms

// Branch, simulate, merge: agents go deliberate
const branch = await db.branch.fork('experiment-A');
await db.branch.merge(branch, 'trunk');

Engineered for the Autonomous Hot Path

Six fundamental technical innovations that separate Axonio from general-purpose databases.

Vector + Graph + State

Hybrid Memory Engine

Combines HNSW vector quantization with in-memory graph adjacency indexes. Query semantic similarity and structural entity relationships in a single transactional call.

Zero Network Hops

Local-First & Embeddable

Embed Axonio directly inside your Python, Rust, C++, Go, or TypeScript process. Run offline on edge robots or local developer machines with zero external service dependencies.

0.38ms P99 Latency

Sub-0.4ms hot-path retrieval

Engineered specifically for low-latency agent reasoning turns and physical robot motion loops, keeping memory access well inside real-time deadlines.

Copy-on-Write Forks

Zero-Copy State Branching

Instant memory forks for sandbox simulation, speculative planning, and A/B policy testing without mutating production memory.

WAL Storage

ACID Crash-Safe Journal

Write-Ahead Log (WAL) journaling ensures state is never corrupted during unexpected process restarts or edge power cuts.

Self-Host Anywhere

Open Source (MIT)

100% open-source core runtime. Inspect the source, run it locally, bundle it into commercial appliances, or deploy to private sovereign clouds with no license fees.

Hardware-Conscious Performance Specs

Built for deterministic execution across x86_64, ARM64, and embedded SOCs.

Vector Index
HNSW + Scalar Quantization (8-bit/4-bit)

Instant cosine, dot, and L2 distance searches across millions of embeddings

Graph Engine
Adjacency list with temporal validity interval

B-Tree indexed entity relationships, automated deduplication & prune

Storage Layer
LSM-tree with append-only Write-Ahead Log

Zero data loss on crashes with deterministic replay & snapshotting

Branching Runtime
Copy-on-write page table with zero-copy merge

Instant fork creation in <2ms regardless of dataset size

Frequently Asked Questions

Is the Axonio Database Engine free and open-source?

Yes. The core database engine is MIT-licensed and 100% open source on GitHub. You can embed it in your own software, run it locally, and self-host it commercially without license fees.

How does Axonio achieve sub-0.4ms retrieval latency?

Axonio is built from the ground up for agent and robot memory rather than general document search. It uses SIMD-accelerated vector quantization, cache-conscious graph structures, and zero-allocation memory pools in native code.

Can I embed Axonio inside robot hardware with no internet connection?

Yes. Axonio compiles to standalone C++ and Rust binaries, WebAssembly, and Python wheels. Devices like warehouse AMRs or drones can run local embedded memory offline with automatic cloud synchronization when connected.

Can I switch from local self-hosted to the hosted Axonio cloud gateway?

Yes. Both read and write the exact same memory format. Migrating simply means changing your connection string from local embedded mode to the hosted MCP / REST endpoint.

Give your agents a memory they can branch.