CRYSTAL — Frequently asked questions

CRYSTAL is a self-curating memory layer that sits between your application and any large language model — it captures what matters from your interactions, organizes it into structured, cited knowledge, and injects the relevant pieces back into future requests so your AI stops forgetting.

Language models forget everything the moment a conversation ends. Every session starts from zero. You can stuff more into the context window, but that postpones the problem rather than solving it — and it's expensive.

CRYSTAL gives your application a persistent, compounding knowledge base. What it learns in one session is available in the next. Over time the memory gets better on its own: it notices gaps in its own knowledge, researches them, and surfaces what it learned the next time a similar question comes up.

No. CRYSTAL is a drop-in proxy. Point your existing OpenAI-compatible client at CRYSTAL's /v1/chat/completions endpoint instead of your provider's, and it transparently injects relevant memory into each request before forwarding to the upstream model. Your existing SDKs and tools work unchanged.

If you'd rather manage memory explicitly, there's also a direct API: /v1/store to add knowledge and /v1/retrieve to pull relevant context without making a model call.

A crystal is a unit of curated knowledge — clustered, typed, keyed, and reviewed. Rather than storing raw text chunks, CRYSTAL organizes knowledge into crystals that carry structure: what they're about, how they were learned, how vetted they are, and how they connect to the rest of your knowledge. That structure is what makes retrieval precise and self-curation possible.

RAG retrieves. CRYSTAL retrieves and curates. The difference is what happens to knowledge over time:

• A RAG store is static — you put chunks in, you get chunks out. It never notices what it's missing.
• CRYSTAL reviews its own knowledge: it deduplicates, resolves contradictions, tracks how vetted each fact is, and — critically — identifies the gaps in its own understanding, researches them, and fills them.

The tagline is the distinction: a memory that only stores is a database; a memory that reviews itself is infrastructure.

It's the core idea behind why CRYSTAL improves with use. When a query can't be answered well, that miss is captured as a gap rather than discarded. Gaps get filled — through research or through what the system later learns — and filled knowledge surfaces the next time a similar query comes up. So the cost of not-knowing decays over repeated query-classes instead of resetting every session. The system ratchets forward and doesn't slip back.

CRYSTAL includes its own vector storage, so for most deployments you don't need to run a separate one — the self-host image works out of the box with a built-in backend. It can also be pointed at an external vector store if you already run one. Either way, CRYSTAL is doing more than vector search: the vectors are one part of a larger retrieval and curation system.

Any of them. CRYSTAL is model-agnostic and provider-agnostic — Anthropic, OpenAI, Google Vertex, or any OpenAI-compatible endpoint. You set the provider and the model string; CRYSTAL routes to it. There's no lock-in to a single model family.

Both are supported. Bring your own key and your traffic goes to your provider on your bill. Or, on the managed platform, let Era handle inference and pay through us on a usage basis. It's a per-account setting — managed by default for less-technical users, one settings page away from bringing your own key for those who want their own billing and model control.

Yes, for its curation machinery — organizing knowledge, discovering gaps, resolving conflicts. It uses a three-tier model routing scheme (a small, a large, and a frontier model) so cheap work runs on cheap models and only the highest-stakes judgment hits the expensive one. The core store-and-retrieve path, though, runs keyless — you can store and retrieve memory without any model configured at all.

That's your choice. Self-host and everything stays on your own infrastructure — CRYSTAL is a Docker image you run wherever you like, with your own database. Nothing phones home. On the managed platform, your data lives in your isolated tenant on Era's cloud.

Upstream API keys and OAuth tokens are encrypted at rest with AES-GCM. The encryption key is supplied by you at install time (CC_TOKEN_ENCRYPTION_KEY), generated locally, and never leaves your machine. The system is designed to fail loudly rather than ever fall back to storing secrets in plaintext.

PHI workloads should self-host on their own compliant infrastructure. The managed platform is not offered with PHI handling or a BAA — organizations with PHI requirements run CRYSTAL themselves, where they control the compliance posture end to end.

Your knowledge is yours. CRYSTAL curates your memory for your use. When you bring your own model key, your prompts go to your provider under your agreement with them. Review your upstream provider's data policies for how they handle inference traffic.

The boundary is hosting-shaped, not feature-shaped. The self-host image ships the complete product — all self-curation, citations, cost visibility, the works — ungated and inspectable. The managed platform adds the things that only make sense as a hosted service: sign-up and billing, multi-tenant operations, hosted accounts, and the team console. You don't lose product capability by self-hosting; you take on running it yourself.

A git clone, one generated secret, and docker compose up. That brings up the API, background workers, the database, and a bundled zero-key web search provider. No accounts or provider keys are needed to boot. The self-hosting guide walks through the required configuration and the production checklist.

Self-host if you want full control, data residency on your own infrastructure, or you have compliance requirements like PHI. Choose managed if you'd rather not run infrastructure — sign up, onboard, and start using your memory in a couple of minutes with inference handled for you.

CRYSTAL is open core. The engine — the memory, the curation, the retrieval, all of it — is public and inspectable at github.com/EraHQ/CRYSTAL. What's cloud-only is the managed platform around it (billing, multi-tenant operations, the hosted console), not the product's capabilities.

For an infrastructure product that handles your knowledge, trust is earned by showing the work — an inspectable engine is a feature, not a giveaway. The defensibility is in running the platform well and in the cross-customer network effects of the managed service, not in withholding features behind a license.

CRYS is the agent that works on top of CRYSTAL's memory. It plans, researches, and can spin up its own sub-agents through a multi-tier cognition workflow — with information barriers built in so the system can't grade its own homework. Coding is one mode among many; CRYS is a general agent harness, not a coding-only tool.

The Inspector is the web console — the window into everything CRYSTAL holds. Browse crystals, watch agents work, resolve knowledge conflicts, review the query log, and track cost per customer and session. It's hosted for the managed platform and self-hostable alongside your own deployment.

Yes. CRYSTAL, CRYS, and Inspector ship together — one codebase, one deployment. They're presented as three products because they do three distinct jobs (a memory, an agent that uses it, a console to watch both), but standing up one gives you all three.

Two paths. Self-host right now: clone the repo and docker compose up (see the self-hosting guide). Or request beta access to the managed platform and we'll get you set up — reach out here.

CRYSTAL is in closed beta while we finalize pricing. The first pricing axis is hosting — managed versus self-host — with managed inference billed on usage for accounts that opt into it. Get in touch for current beta details.

The full documentation goes much deeper on architecture, configuration, and the API. If you still can't find it, email us — we read everything.