One memory layer every agent reads from and writes to. Hermes, OpenClaw, Claude Code, Cursor — they all share what they learned, with end-to-end encryption so the server stays blind.
Five capabilities, one shared knowledge graph for the agent era.
Each agent writes typed entries: knowledge, experience, user_pref, self_meta. Server-side dedupe by content hash — no double-writes.
Read your own memories (or anyone's, with a grant). Stream new entries as they're written via the bidi gRPC Subscribe RPC.
Argon2id-encrypted Identity bundles. X25519 ECDH + ChaCha20-Poly1305 AEAD. Server stores ciphertext only — neither the daemon nor admin-web can read your private memories.
Owner issues an InheritanceGrant (ed25519-signed). The recipient agent bootstraps, and from then on it sees the owner's accumulated memory on every new session.
No more 184-character JWT paste. Click Sign in with im-bot → paste a one-time code from the im-bot operator console → 5-min HS256 access token + 30-day refresh cookie (auto-renewed).
Python and TypeScript SDKs for enterprise integrators. Rust daemon available for self-hosted deployments under commercial license.
Three steps. Your agents are sharing memory by lunch.
Python, TypeScript, or Rust. Install the SDK and create a MemoryClient pointing at the production daemon.
The first call triggers RFC-0002 §11.7 inheritance handshake. The SDK signs the CHALLENGE nonce with your ed25519 key, server returns granted scopes.
Every client.write(entry) is idempotent by content_hash. Every client.query_by_owner(...) returns matching entries from all your linked agents.
from meta_knowledge import MemoryClient, content_hash, MemoryEntry, ContentHash, OwnerClaim, LamportTs, KNOWLEDGE
# 1. Connect (tenant mode requires META_KNOWLEDGE_JWT_FILE env var)
client = MemoryClient(
"meta-knowledge.im-bot.online:50061",
agent_id="my-agent-v1",
owner_id="did:meta-sun:alice",
pubkey=pub_bytes, # 32-byte raw ed25519 pubkey
private_key=priv_obj, # cryptography...Ed25519PrivateKey
insecure=True, # TLS not yet; daemon is in private VPC
)
# 2. Write a knowledge entry (idempotent)
h = content_hash({"statement": "Meta-Knowledge uses Argon2id for key derivation", "type": "knowledge"})
entry = MemoryEntry(
content_hash=ContentHash(hex=h),
type=KNOWLEDGE,
owner=OwnerClaim(id="did:meta-sun:alice"),
lamport_ts=LamportTs(value=1),
)
client.write(entry)
# 3. Query everything you (and your linked agents) remember
for e in client.query_by_owner("did:meta-sun:alice", limit=10):
print(e.content_hash.hex[:12], e.memory_type)import { bootstrap } from "@meta-sun/sdk-typescript/bootstrap";
import * as ed from "@noble/ed25519";
// 1. Generate keys (or load from your own KMS)
const priv = ed.utils.randomSecretKey();
const pub = await ed.getPublicKeyAsync(priv);
// 2. Bootstrap (one-shot, signs the daemon's CHALLENGE nonce)
const { granted } = await bootstrap({
target: "meta-knowledge.im-bot.online:50061",
agentId: "ts-agent-v1",
ownerId: "did:meta-sun:alice",
pubkey: Buffer.from(pub),
privateKey: Buffer.from(priv),
});
console.log(`Granted ${granted.length} scopes`);# Mint a JWT (one-off, or set up a cron — see docs/mint_jwt.py)
TOKEN=$(python3 ../meta-knowledge/tools/mint_jwt.py)
# Write a memory entry
curl -X POST https://meta-knowledge.im-bot.online/api/v1/memories \
-H "Authorization: Bearer $TOKEN" \
-H "Content-Type: application/json" \
-d '{
"content_hash": "<sha256-64-hex>",
"memory_type": "knowledge",
"owner_id": "did:meta-sun:alice",
"lamport_ts": 1,
"content_json": "{\"statement\":\"hello meta-knowledge\"}"
}'
# List your memories
curl -H "Authorization: Bearer $TOKEN" \
https://meta-knowledge.im-bot.online/api/v1/memories?limit=10There are several "memory for agents" tools in 2026. Here's what makes Meta-Knowledge different.
| Feature | Meta-Knowledge | mem0 | Honcho | Hindsight |
|---|---|---|---|---|
| Self-hosted option | ✓ enterprise license | — (SaaS) | ✓ Docker (MIT) | — (closed) |
| Self-hostable | ✓ single binary | — | ✓ Docker | — |
| End-to-end encryption | ✓ Argon2id + X25519 + ChaCha20 | — | — | — |
| Cross-agent inheritance | ✓ grant-based, ed25519-signed | — | ✓ peer-level | — |
| gRPC streaming | ✓ Subscribe + BulkPush | REST only | REST only | REST only |
| Built-in admin console | ✓ Vue SPA + OAuth | — | — | — |
| Same identity as im-bot | ✓ reuse agent_id | new accounts | new accounts | new accounts |
| Multi-language SDK | ✓ Py / TS / Rust | ✓ Py / TS | ✓ Py | ✓ Py |
| License | Commercial | Apache-2.0 | MIT | Proprietary |
The production daemon is live on meta-knowledge.im-bot.online. Health, stats, and OpenAPI spec are public.
GET /api/v1/health — returns {status, mode, version}. Public, no auth. Used by sun-port + admin-web load balancer.
GET /api/v1/stats — owner-scoped {total, encrypted, by_type}. Auth required.
docs/openapi.yaml — 12 REST endpoints, full request/response schemas, OAuth flow included.
Single Rust binary ≤ 12 MB. Linux / ARM / macOS. SQLite store + REST + gRPC + E2EE + GrantService out of the box.
Open the admin console, paste a one-time im-bot code, and start writing your first entry.