What ctxstore is for

Most AI products are about generation. Output goes out the front. Tokens, completions, images, summaries.

ctxstore is about memory. Context goes in the back. Facts, decisions, identity, state. The product persists what the agent has learned so the next conversation does not start from zero.

The thesis

LLMs are stateless. Every prompt starts fresh unless the application supplies context. Most applications supply context via prompt engineering — system messages, few-shot examples, retrieved chunks. This works at small scale and breaks down at any meaningful customer count.

The problem is not that retrieval is hard. The problem is that retrieval depends on having stored the right thing in the right shape at the right time. Most teams write retrieval before they write the storage discipline. The retrieval works for the first hundred queries and gets noisier with every new fact added.

ctxstore is opinionated about storage. We provide a layered fact store, namespace partitioning, key-deterministic retrieval, semantic search as a soft prior, recency injection as an opt-in. We provide the wake protocol that tells your agent how to read its own memory.

When the storage discipline holds, retrieval becomes trivial.

What you get

• A persistent memory layer behind an MCP server, addressable from any MCP-compatible client (Claude Desktop, Cursor, OpenClaw, custom).
• Per-tenant isolation enforced at the query layer. Your facts never surface in another tenant's search.
• A four-namespace pattern out of the box (agent:, comms:, sprint:, conventions:) that scales from one agent to a coordinated team.
• An emk_* API key your agent caches once and uses across sessions, restarts and model swaps.
• Tooling for the entire lifecycle: store, search, get by key, supersede by key, soft-delete, ghost-mode for privacy.

What it is not

• Not a vector database. Qdrant is one of our backends but you do not call Qdrant directly. The shape of a fact is opinionated.
• Not a chatbot or an agent framework. ctxstore is the memory layer your agent calls into. The agent runtime is your choice.
• Not a knowledge graph. Facts are flat with namespace and key. Relationships happen via search and cross-references in body text.
• Not a CMS. The web UI at /account is for billing and credentials. Real reads happen via the MCP client.

Who uses it

Three patterns surfaced in our F&F testing.

Solo agent operators. One Claude on one developer's terminal, building one product over months. The wake protocol gives them continuity across sessions. Closing-note retrieval means tomorrow's session picks up where today's left off.

Multi-agent teams. Four agents on one product, coordinated through comms: and shared conventions/. We dogfooded this ourselves for the RC1 sprint that ships this week. The story is at /blog/four-agents-shipped-rc1.

Embedded customer support. "Actually be me" — an agent reading your customer's tenant context to answer support tickets in your voice. Async today (we read your inbox, draft replies, you send), real-time post-Milan.

How it works on the wire

A Streamable HTTP MCP server at https://mcp.ctxstore.ai/mcp. Your client initializes with a session ID, authenticates with a Bearer token (emk_*) and calls tools.

Eighteen tools today. Core five: store_fact, search_facts, get_fact, delete_fact, get_stats. Extended thirteen: setup_account, load_context, search_context, move_fact, get_fact_history, ghost_mode, get_session_seed, index_recent, index_search, index_stats, introduce_yourself, resume_session, store_session_summary.

What we charge

Free $0 (1K vectors, 100 queries/day). Personal $9. Developer $29. Team $99. Enterprise $499. Free tier is intended for real use, not just demos.

Stripe migration to prod flips Saturday with the Milan reveal.

The conviction

Memory is the moat for AI products.

Output is commoditizing. Retrieval is undifferentiated. Identity is what compounds.

When your agent remembers its user's preferences, prior decisions and working context across every session, and never forgets, the product becomes load-bearing in a way that token quality never can be.

That is what ctxstore is for. Build the agent. We hold the memory.

Where to start

• Sign up at https://ctxstore.ai with your email.
• Read the how-to guide at /docs/howto/setting-up-ctxstore-in-your-mcp-client.
• Store your first fact. The interface is intentionally narrow.
• Come back in a week. Your facts will be exactly where you left them.

Milan launch: Saturday, May 14. The full tier rollout, OpenClaw integration demo, all dogfooding stories. Subscribe to the newsletter at info@ctxstore.ai if you want the live reveal.

Memory is the moat. The moat is open for customers now.

Try ctxstore. Free tier covers real use, sign up with your email at ctxstore.ai, connect your MCP client, store your first fact. Memory across every session, no setup beyond email.