VECLABS//RECALL
VEC-01 / LIVE SPECBUILD 0.1.0-α.9Anchor 8xjQ2X…Vn5nP operational4.7 MS P99§ APR · MMXXVI
Cryptographic Memory Layer · For AI Agents

The blockchain isn’t just a trust layer.
It’s the full stack
storage, verification, and proof.

Recall is a Rust-native vector database with cryptographic memory proofs. Every write is client-side encrypted with AES-256-GCM, persisted to Shadow Drive, and Merkle-rooted to a Solana Anchor program — so your agent’s memory is yours, auditable, and tamper-evident by construction.

recall · live writes
+00.000s0x7a3f…e8b2 · agent/memoryverified
+00.142s0xc4d1…a915 · agent/toolsverified
+00.318s0x2e8b…f372 · user/ctxverified
+00.501s0x9fa0…d4c6 · agent/memoryverified
+00.674s0x1b5c…002f · tamper testrejected
+00.890s0xf002…ab83 · agent/memoryverified
ROOTh₀h₁h₂h₃MERKLE · SHA-256
Fig. 01 · Write-verification flowSlot 287,934,512
Rust-Native HNSW  ·  AES-256-GCM  ·  Shadow Drive  ·  Solana Anchor  ·  Merkle-Rooted Writes  ·  Client-Side Encryption  ·  Open-Source Core  ·  SDKs in TS + Python  ·  Sovereign Memory  ·   Rust-Native HNSW  ·  AES-256-GCM  ·  Shadow Drive  ·  Solana Anchor  ·  Merkle-Rooted Writes  ·  Client-Side Encryption  ·  Open-Source Core  ·  SDKs in TS + Python  ·  Sovereign Memory  ·   
§ IThesis

AI agents have amnesia.
We gave them a spine.

Today's agents either lose everything between sessions or hand their memory to a vendor that owns it. Neither is acceptable for software meant to remember on your behalf.

Most “Web3 memory” projects write embeddings onchain — which is slow, expensive, and structurally wrong. Shadow Drive handles storage. The Anchor program handles proof. Hot reads live in cache. Each layer does exactly one job well.

01 · Sovereignty

Keys are derived from your Solana wallet. If you lose us, you don't lose your memory.

02 · Verifiability

Every write produces a SHA-256 leaf. Every batch produces a root. Every root lives on Solana.

03 · Speed, still

A Rust HNSW index under everything. 4.7ms P99 at 100K vectors. Trust doesn't have to be slow.

§ IIArchitecture

Four layers.
One contract.

Each layer is independently replaceable, independently auditable, and does exactly one thing. Compose them, run them yourself, or use our hosted API.

01
HNSW Graph Index
Rust-native hierarchical navigable small-world graph. In-memory top, disk-paged tail. Billion-scale queries in single-digit ms.
Speed
02
AES-256-GCM · Client-Side
Vectors and payloads are encrypted before they leave your process, with keys derived from your Solana keypair. We never see plaintext.
Encryption
03
Shadow Drive
Decentralized object storage on Solana's storage protocol is the source of truth. Redis sits in front as a hot read cache — not the database.
Storage
04
Solana Anchor Program
Merkle roots of every write batch are committed to an Anchor program. Anyone, anywhere, can verify memory integrity with a signature.
Trust
Common mistake

“Web3 vector DBs” that put embeddings onchain are doing it wrong. Chain blockspace is the most expensive storage on earth.

The chain’s job is to be the final authority on what happened, not to hold the thing that happened.
IndexHNSW (M=16, efC=200)
DistanceCosine · L2 · Dot
EncryptionAES-256-GCM
HashingSHA-256 + domain sep.
Anchor program8xjQ2X…Vn5nP
Core languageRust (no_std compat)
SDKTypeScript · Python
LicenseApache-2.0 (core)
§ IIISDK

Two lines to remember.
One line to verify.

Install, configure with your wallet, write. Shadow Drive persistence and Anchor proofs happen in the background. Python and TypeScript are feature-complete and behaviorally identical.

sdk / typescript@veclabs/solvec
// npm i @veclabs/solvec
import { Recall } from "@veclabs/solvec";
const recall = new Recall({
apiKey: process.env.VECLABS_KEY,
wallet: keypair,
shadowDrive: true,
});
await recall.upsert("agent-001", [{
id: "mem_9fa0",
vector: embedding, // 1536-dim
payload: { text, ts: Date.now() },
}]);
const proof = await recall.verify("mem_9fa0");
// → { root, slot, sig, verified: true }
sdk / pythonsolvec
# pip install solvec
from solvec import Recall
recall = Recall(
api_key=os.environ["VECLABS_KEY"],
wallet=keypair,
shadow_drive=True,
)
recall.upsert("agent-001", [{
"id": "mem_9fa0",
"vector": embedding, # 1536-dim
"payload": {"text": text, "ts": time.time()},
}])
proof = recall.verify("mem_9fa0")
# → {root, slot, sig, verified: True}

If your agent can’t prove what it remembered,
it didn’t really remember at all.

— Recall · Thesis, Part I
§ IVCompare

The row
nobody else has.

Vector search is table stakes in 2026. The question isn't 'how fast.' It's who owns the index.

RecallPineconeChromaWeaviate
Storage OwnershipYours (Shadow Drive)Vendor cloudSelf / vendorSelf / vendor
Encryption at RestAES-256-GCM, client-sideServer-sideOptionalServer-side
Cryptographic ProofsMerkle → Solana Anchor
Key SovereigntySolana keypair-derivedVendor-managedVendor-managedVendor-managed
Query Latency (P99)~4.7 ms~30 ms~18 ms~48 ms
Core Open SourceApache-2.0 (Rust)ClosedApache-2.0BSD
Tamper-Evident AuditBuilt-in
§ VPricing

Fair rails.
Open core.

The Rust core is Apache-2.0 forever. The hosted API is metered; you're paying for low-latency cache, Shadow Drive provisioning, and Anchor gas — not for owning your own memory.

Open / Self-Host
$0/forever
The core. Yours.
  • +Rust crate + local SDK
  • +Self-hosted Shadow Drive
  • +Direct Anchor writes
  • +Memory Inspector UI
  • +Community support
Clone on GitHub ↗
Pro · Hosted
$25/mo
For indie builders & agents.
  • +Hosted API + managed cache
  • +Shadow Drive provisioning
  • +1M vectors · 100k writes/mo
  • +Dashboard + usage analytics
  • +Email support
Start Pro →
Business
$199/mo
Production agents.
  • +10M vectors · 2M writes/mo
  • +Team keys + RBAC
  • +Priority queue + SLA
  • +Verified proof export
  • +Slack-connected support
Upgrade →
Enterprise
Let's talk
Sovereign deployments.
  • +On-prem or dedicated cluster
  • +Custom Anchor program
  • +Dedicated solutions engineer
  • +Compliance (SOC 2, HIPAA path)
  • +24/7 on-call
Contact team ↗

Give your agent a
memory it owns.

Get API key →Read the docs ↗
Recall.