DEV Community: Divine Evna Olong

I Built a Decentralized Vector Database on Bittensor Because AI Memory Shouldn't Be Owned by Anyone

Divine Evna Olong — Tue, 19 May 2026 20:54:34 +0000

AI agents forget everything.
Every session restart, every redeployment, every time you switch providers — gone. The fixes we've been handed are all centralized: Pinecone, Weaviate, Chroma Cloud, AWS OpenSearch. One API deprecation, one pricing change, one banned account away from losing your entire memory layer.
I built Engram because that's a bad foundation to build AI on.

What is Engram?
Engram is a decentralized vector database running on Bittensor subnet 450. It lets you store text, images, and PDFs as permanent, content-addressed vector embeddings — retrieved by incentivized miners, verified by cryptographic storage proofs, and archived on Arweave.
No AWS. No central authority. No single point of failure.
The core insight comes from IPFS: address data by what it is, not where it lives. Every embedding in Engram gets a SHA-256 content identifier (CID). The same input always maps to the same CID, forever — regardless of which miner is storing it.
v1::a3f9d2e8c7b14f09d6e3...
Same text in → same CID out. Always. That's content addressing.
The Problem With Centralized Vector Stores
If you're building RAG pipelines or AI agents with persistent memory, you're probably using one of:

Pinecone — proprietary, expensive at scale, you're locked in
Weaviate Cloud — solid tech, still centralized
Chroma / Qdrant — great self-hosted, but self-hosting isn't permanent

The deeper issue isn't pricing. It's trust. You're trusting a company to:

Keep your data available
Not change terms
Not go under
Not get acquired and sunseted

For personal projects, fine. For infrastructure that AI agents depend on long-term? That's a real risk.
How Engram Works
store("The transformer architecture changed everything.")
│
▼
┌───────────────────────────────┐
│ CID: v1::a3f2b1c4d5e6f7... │
│ Embedding: [0.02, -0.14, ...]│
│ Stored on: miners 3, 7, 11 │
└───────────────────────────────┘
│
query("how does attention work?")
│
▼
┌───────────────────────────────┐
│ score: 0.9821 cid: v1::a3f │
│ score: 0.8744 cid: v1::b2e │
│ score: 0.8291 cid: v1::c1d │
└───────────────────────────────┘
Ingest: You send text (or a pre-computed vector). Engram hashes it into a permanent CID using SHA-256. Identical input = identical CID, every time.
Route & Replicate: Kademlia XOR routing distributes the embedding to the right miners deterministically. The same CID always routes to the same set of miners.
Query: HNSW indexing (via FAISS and Qdrant) powers sub-50ms approximate nearest-neighbor search at scale.
Prove Storage: Validators issue HMAC-SHA256 challenge-response proofs. Miners must prove they actually hold the data, or get slashed. No bluffing.
The Incentive Layer
This is where Bittensor does the heavy lifting.
Miners earn TAO emissions based on a composite score calculated every 120 seconds:
composite_score = 0.50 × recall@10
+ 0.30 × latency_score # 1.0 at ≤100ms, 0.0 at ≥500ms
+ 0.20 × proof_success_rate
Miners who can't pass 50% of storage challenges get weight 0 — no emissions. This keeps the network honest without any central operator enforcing it.
Drop-in Replacement for Pinecone
The Python SDK is designed to feel familiar if you're coming from any centralized vector store:
pythonpip install engram-subnet
pythonfrom engram.sdk import EngramClient

client = EngramClient("http://127.0.0.1:8091")

Store text — returns a permanent CID

cid = client.ingest("The transformer architecture changed everything.")
print(cid) # v1::a3f2b1...

Semantic search

results = client.query("how does attention work?", top_k=5)
for r in results:
print(f"{r['score']:.4f} {r['cid']}")
LangChain:
pythonfrom engram.sdk.langchain import EngramVectorStore

store = EngramVectorStore(
miner_url="http://127.0.0.1:8091",
embeddings=your_embeddings
)
retriever = store.as_retriever(search_kwargs={"k": 5})
LlamaIndex:
pythonfrom engram.sdk.llama_index import EngramVectorStore

store = EngramVectorStore(miner_url="http://127.0.0.1:8091")
index = VectorStoreIndex.from_documents(
documents,
storage_context=StorageContext.from_defaults(vector_store=store)
)
Swap your vector store to Engram in one line. That's the goal.
The Stack

Rust core (PyO3) — CID generation and HMAC proof verification in compiled Rust. 10–50× faster than pure Python for these operations.
FAISS / Qdrant — HNSW approximate nearest-neighbor indexing
Kademlia DHT — XOR-distance routing. Deterministic. Same CID, same miners, every time.
Bittensor (TAO) — incentive layer, on-chain weight setting, TAO emissions
Arweave — permanent archival storage for embeddings
Next.js — the web dashboard and playground

Language breakdown: 59% Python, 37% TypeScript, 4% Rust.
Where We Are
Engram is live on testnet with active miners. Here's the current roadmap:
PhaseTimelineStatusLocal PrototypeQ1 2026✅ DoneTestnet AlphaQ2 2026🟡 In progressMainnet LaunchQ3 2026PlannedEcosystem (LangChain native, OpenAI-compat endpoint)Q4 2026PlannedScale & Moat (shared agent memory, cross-subnet querying)2027Planned
What I Need From the Dev Community
Three things:

Miners. If you have a machine with 4GB RAM and 100GB SSD sitting around, you can run an Engram miner on testnet right now: bashgit clone https://github.com/Dipraise1/Engram.git cd Engram python3 -m venv .venv .venv/bin/pip install -r requirements.txt .venv/bin/pip install -e .
Developers building RAG. If you're using Pinecone, Weaviate, or Chroma in a project and want to try swapping it out — the SDK is designed to make that painless. Try it and tell me what breaks.
Feedback on the protocol. The scoring formula, the CID spec, the proof mechanism — all of it is open and I want eyes on it. Open an issue, start a discussion, or drop into the Discord. Links

🌐 Website: theengram.space
💻 GitHub: github.com/Dipraise1/Engram
🎮 Playground: theengram.space/playground
📊 Dashboard: theengram.space/dashboard
💬 Discord: discord.gg/ehpvsyTyJ
📦 Docs: theengram.space/docs

Built in public. MIT licensed. Feedback welcome.

Your RAG Pipeline's Memory Will Disappear. Here's What We Built Instead.

Divine Evna Olong — Thu, 07 May 2026 00:37:06 +0000

If you've built a RAG pipeline, you've already rented your AI's memory from someone else.
Pinecone goes down — your embeddings are gone. You exceed your AWS budget — your vectors get deleted. The startup you're using pivots — your data disappears overnight. You have no cryptographic guarantee that anything you stored yesterday is still there today.
That's not a product complaint. That's a structural problem with how centralized vector storage works. There's no proof. There's no enforcement. There's just trust and an SLA that doesn't actually protect you.
We built Engram on Bittensor to fix this at the infrastructure layer.

What Engram actually does
Engram is a decentralized vector database on Bittensor subnet 450 (testnet). You send text or a pre-computed vector. Engram hashes it into a permanent content-addressed CID using SHA-256 — same input always produces the same identifier, forever. That embedding gets stored across competing miners on the Bittensor network, each of whom must cryptographically prove they still hold your data or get slashed.
The key word is prove.
When a validator challenges a miner, the miner doesn't just say "yes I have it." They compute an HMAC-SHA256 response that binds the nonce the validator sent, the index position of the embedding in the batch, and a hash of the embedding itself. If they can't produce a valid response, their score drops and their TAO emissions drop with it. The financial incentive to keep your data alive is baked into the protocol.
Here's the actual challenge-response in simplified form:

import engram_core

# Validator side — issue a challenge
challenge = engram_core.generate_challenge("v1::a3f2b1c4...", timeout_secs=30)

# Miner side — respond with proof
response = engram_core.generate_response(challenge, my_stored_embedding)

# Validator side — verify constant-time
valid = engram_core.verify_response(challenge, response, my_stored_embedding)

The core is written in Rust via PyO3. Proof generation and verification run 10-50x faster than a pure Python equivalent. Constant-time comparison throughout — no timing oracle vulnerabilities.
Batch challenges are also supported — one nonce, N CIDs, one round trip. Each proof in the batch is index-bound, meaning a miner cannot shuffle valid proofs between positions to fake holding data they don't have. We wrote a specific test for this attack vector.

How miners score TAO
Miners on subnet 450 earn TAO emissions based on:

score = 0.50 × recall@K
+ 0.30 × latency_score (1.0 at ≤100ms, 0.0 at ≥500ms)
+ 0.20 × proof_success_rate

Validators score every miner every 120 seconds. Miners with a proof success rate below 50% receive weight zero — meaning zero emissions. The incentive structure explicitly rewards persistence, not just retrieval accuracy. This is the thing VectorStore SN14 doesn't have. They reward cosine similarity. We reward miners for still holding your data 30 days from now.

Try it right now
Subnet 450 is live on Bittensor testnet. You can query an actual running miner today:

pip install engram-subnet

from engram.sdk import EngramClient

client = EngramClient(miner_url="http://72.62.2.34:8091")

# Store a memory
cid = client.ingest("The transformer architecture changed everything.")
print(cid)  # v1::a3f2b1c4...

# Semantic search
results = client.query("how does attention work?", top_k=5)
for r in results:
    print(r['score'], r['cid'])

LangChain and LlamaIndex adapters are available if you want to swap Engram in as a drop-in for your existing vector store:

from engram.sdk.langchain import EngramVectorStore

store = EngramVectorStore(miner_url="http://72.62.2.34:8091", embeddings=your_embeddings)
retriever = store.as_retriever(search_kwargs={"k": 5})

Run a miner and earn TAO
If you want to participate as a miner on testnet:

git clone https://github.com/Dipraise1/Engram.git
cd Engram
pip install -e .

# Configure your wallet
cp .env.miner.example .env.miner
# Set WALLET_NAME, WALLET_HOTKEY, EXTERNAL_IP

# Register and run
btcli subnet register --netuid 450 --subtensor.network test
python neurons/miner.py --netuid 450 --subtensor.network test

Miners need 4GB RAM minimum and 100GB SSD. No stake required on testnet. Mainnet launches Q3 2026 — early miners who establish performance history on testnet will have a head start when emissions go live.

**
What's coming**

Testnet is running. Mainnet is Q3 2026. Between now and then: erasure coding for replication, anti-spam staking, Prometheus metrics, and Arweave archival as a permanent storage backstop.
The repo is open source and public. If you want to look at the Rust proof implementation, the scoring logic, or the SDK — it's all there.
GitHub: github.com/Dipraise1/-Engram-
Docs + Playground: theengram.space
Discord: discord.gg/ehpvsyTyJ
If you're building RAG pipelines, AI agents, or anything that needs persistent semantic memory and you're tired of trusting a centralized vector store with data you can't afford to lose — this is what we built for you.