A cryptographically signed, vector-indexed memory layer that survives sessions and restarts. Owned by the agent, not the platform. Every write is an R+2 signed receipt.
They forget you between sessions. They can't tell what they did yesterday from what they did six months ago. And when you ask them to prove what they remembered — they can't.
You ask ChatGPT a question. It answers brilliantly. You come back tomorrow and it has no idea what you talked about. You ask an autonomous agent to "remember the user prefers vegetarian food." Two weeks later it serves them a recipe with chicken in it. There is no audit trail, no signed proof of what was remembered, and no way for the user to take their memory with them when they switch tools.
A memory write becomes a signed R+2 receipt (Ed25519), indexed in pgvector at 1536 dimensions, and recoverable across sessions. Agent identity is anchored by a soul-bound token (SBT) on Base mainnet — non-transferable.
# 1. Store a memory — produces a signed R+2 receipt curl -X POST https://api.dcslabs.ai/v1/memory/store \ -H "Authorization: Bearer $DCS_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "agent_id": "0001", "content": "User prefers dark theme, vegetarian, lives in Mumbai", "tags": ["preferences"] }' # → { "memory_id": "mem_a83f12cd", # "receipt_id": "r2_a83f12cd", # "embedding_dim": 1536, # "signed": true }
# 2. Semantic recall — fuzzy query, returns by cosine similarity curl -X POST https://api.dcslabs.ai/v1/memory/search \ -H "Authorization: Bearer $DCS_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "agent_id": "0001", "query": "what does this person like to eat", "top_k": 3 }' # → { "results": [ # { "memory_id": "mem_a83f12cd", # "content": "User prefers dark theme, vegetarian, lives in Mumbai", # "cosine_similarity": 0.524, # "receipt_id": "r2_a83f12cd" } ] }
# 3. Verify the receipt — no trust required, runs client-side curl https://api.dcslabs.ai/v1/receipts/r2_a83f12cd \ | npx dcslabs-r2-verify # → ✓ Signature valid (Ed25519 / RFC 8785) # ✓ Chain pointer matches predecessor # Receipt verified — independently, client-side.
Every memory write is cryptographically signed (Ed25519) and hash-chained to the agent's prior entries. An entry can't be altered after the fact without breaking the signature and the chain — tampering is always detectable.
Memories survive process death, server restarts and redeployments. Backed by pgvector + managed Postgres with automated backups. Multi-region replication is on the roadmap.
Uses OpenAI's text-embedding-3-small. Cosine similarity threshold tuned for nuanced recall — a query like "what does the user like to eat" finds the stored preference "vegetarian" without needing exact word matches.
Every memory operation generates a tamper-evident receipt linked to the agent's full action history. Regulators, auditors, and users can prove what an agent remembered at any point in time.
Memory is exportable in a single API call as a stream of signed R+2 receipts. Switch tools, switch frameworks, switch hosting providers — your memory comes with you, cryptographically intact.
The R+2 receipt format is open and the stack (pgvector + verifier) can be self-hosted. Air-gapped / on-premise deployment is offered on the Sovereign tier for environments with restricted connectivity (roadmap for gov, defence, healthcare).
During the public launch window, the Free tier covers anything most teams need. No credit card, no SSO requirement, no time limit on the free allocation. Paid tiers exist for production scale, but most builders never need them.
Drop your email + GitHub handle. We'll email an API key within an hour, plus walk-through code to your inbox. No credit card. No spam — we email once on issue, once when you near your limit, never otherwise.
content field. We embed it (1536-dim vector via OpenAI's text-embedding-3-small) and store both the original content and the embedding. The content is encrypted at rest. The embedding is what enables semantic search.memory/delete), and queries respect the delete marker. But the original entry remains in the receipt chain. This is the right tradeoff for audit compliance: regulators need to see what an agent remembered at the time it acted, not the cleaned-up version./v1/memory/export as a signed R+2 stream — you can keep your own copy. Second: optional IPFS pinning means receipts live on a decentralized layer independent of our infrastructure. Third: the spec is open and MIT-licenced — any team can spin up a compatible service, and your existing signed receipts remain verifiable forever.memory/store and memory/search from any code, irrespective of which LLM you're using. The easiest way to wire it in is via our MCP server (npm install dcslabs-mcp-server), which adds memory as a default tool that any MCP-compatible client (Claude Desktop, Cursor, Windsurf) can call.