Enigma
FAQ

FAQ & objections

Straight answers — including the limits.

Enigma · 2026 · open source · enigmamemory.com

Short answers to pin

What is Enigma?

Enigma is provider-neutral AI memory/proof infrastructure. It gives users and organizations portable Memory Passports, local-first or customer-controlled vaults, scoped context injection into AI workflows, and signed receipts for Enigma-mediated memory lifecycle and boundary events.

Does Enigma have a token?

No. Enigma is token-free. Local vaults, MCP workflows, context packs, and offline receipt verification need no token, no wallet, and no blockchain. The optional relay/witness/gateway network is coordinated through ordinary authenticated service infrastructure.

What is the simplest demo?

Create a local vault, save one memory, export a proof bundle, and verify it:

cd enigma
npm install -g .
enigma init --bundle ./.enigma/bundle.json --subject local-user --display-name "Local user"
enigma remember --bundle ./.enigma/bundle.json --text "Prefers concise release notes." --purpose user_memory --tags preference
enigma context --bundle ./.enigma/bundle.json --query "release notes" --purpose local_answer --out ./.enigma/context-pack.json
enigma export --bundle ./.enigma/bundle.json --out ./.enigma/export.json
enigma verify --bundle ./.enigma/export.json

What does a receipt prove?

A receipt proves that a declared Enigma-mediated operation was signed, ordered, and committed under a stated policy boundary.

A receipt does not prove factual truth, model intent, uninstrumented side-channel absence, or deletion from external providers unless those systems provide independent evidence.

Product fundamentals

What problem does Enigma solve?

AI is becoming stateful, but useful memory is fragmented across providers, apps, vector stores, exports, and agent stacks. Enigma gives memory a neutral home: a local-first or customer-controlled vault, portable passport format, scoped context retrieval, and signed receipts that can be verified later.

Is Enigma a chatbot?

No. Enigma is infrastructure beneath AI clients and agents. It can connect to MCP-capable assistants, browser workflows, desktop surfaces, enterprise gateways, and future relay/witness/gateway infrastructure.

Is Enigma a model provider?

No. Enigma does not train or serve a foundation model. It manages memory, context boundaries, receipts, and optional network coordination around AI workflows.

Is Enigma just a vector database?

No. Enigma may use retrieval concepts, but the product is a memory custody and proof layer: vaults, passports, scoped context, lifecycle receipts, verifier output, connectors, and enterprise/network surfaces.

Is Enigma trying to replace provider-native memory?

No. Provider-native memory can be treated as cache or convenience. Enigma is the canonical memory/proof layer when a user or organization wants portability and evidence independent of one provider dashboard.

What is a Memory Passport?

A Memory Passport is a portable package of AI context controlled by the user, tenant, or delegated controller depending on deployment mode. It is designed to move useful memory across AI tools while preserving receipt evidence about Enigma-mediated operations.

What is a Memory Capsule?

A Memory Capsule is a scoped package of context or memory material prepared for a specific workflow, provider, model, agent, or tool boundary. Capsules should contain only what is authorized for the intended use.

What is a vault?

A vault is the local-first or customer-controlled place where Enigma stores canonical memory state for a deployment path. The local quickstart uses a bundle file such as ./.enigma/bundle.json or $HOME/.enigma/bundle.json.

What is a receipt?

A receipt is a signed, offline-verifiable record of an Enigma-mediated memory lifecycle or boundary event, such as create, import, retrieve, inject, deny, export, tombstone, or delete-request behavior.

What is the verifier?

The verifier checks exported Enigma proof bundles and receipts. The core launch promise is that users can verify evidence without trusting an Enigma dashboard or AI provider dashboard.

Install and local use

What are the requirements?

  • Node.js >=24.
  • A local filesystem path for the Enigma vault bundle.
  • No database, package registry account, or cloud credentials for the local CLI/MCP/verifier path after the package or checkout is present.
  • Optional Docker for containerized relay/gateway operation.

How do I install from this repository?

cd enigma
npm install -g .
enigma --help
enigma-verify --help
enigma-mcp

If you do not want a global install:

cd enigma
node apps/cli/bin/enigma.mjs --help
node apps/verifier/bin/enigma-verify.mjs --help

How do I install from npm?

Install the published package:

npm install -g enigma-memory
enigma --help
enigma help

One-off execution without a global install:

npx --yes --package enigma-memory enigma --help
npx --yes --package enigma-memory enigma help
npx --yes --package enigma-memory enigma-mcp

enigma --help prints JSON usage; enigma help prints compact prose usage with examples.

Can I run Enigma locally without hosted cloud?

Yes, the local CLI/MCP/verifier path can use a local bundle without hosted Enigma cloud services after the package or checkout is present:

mkdir -p .enigma
enigma init --bundle ./.enigma/bundle.json --subject local-user --display-name "Local user"
enigma remember --bundle ./.enigma/bundle.json --text "Prefers concise technical answers." --purpose user_memory --tags preference
enigma context --bundle ./.enigma/bundle.json --query "technical answers" --purpose local_context --out ./.enigma/context-pack.json
enigma export --bundle ./.enigma/bundle.json --out ./.enigma/export.json
enigma verify --bundle ./.enigma/export.json

Windows PowerShell:

New-Item -ItemType Directory -Force .enigma
enigma init --bundle .\.enigma\bundle.json --subject local-user --display-name "Local user"
enigma remember --bundle .\.enigma\bundle.json --text "Prefers concise technical answers." --purpose user_memory --tags preference
enigma context --bundle .\.enigma\bundle.json --query "technical answers" --purpose local_context --out .\.enigma\context-pack.json
enigma export --bundle .\.enigma\bundle.json --out .\.enigma\export.json
enigma verify --bundle .\.enigma\export.json

What should I avoid sharing publicly?

Do not paste raw memory plaintext, prompts, transcripts, credentials, private vault contents, seed phrases, private keys, or customer data into public channels. Exported proof and network artifacts should contain commitments, roots, addresses, receipt IDs, and encrypted payloads where appropriate, not raw memory plaintext.

What if enigma verify fails?

First check whether the receipt or export was edited, copied through a formatter, truncated, or mixed with another bundle. A verifier failure may be the correct result if evidence was changed. If a fresh Enigma export fails, ask in support with commands and redacted output only.

MCP

How does Enigma connect to AI clients?

Enigma connects through MCP. The client starts enigma-mcp over stdio, and Enigma reads/writes the local vault bundle named by ENIGMA_BUNDLE.

How do I run the MCP server?

ENIGMA_BUNDLE="$HOME/.enigma/bundle.json" enigma-mcp

CLI equivalent:

ENIGMA_BUNDLE="$HOME/.enigma/bundle.json" enigma mcp serve

Windows PowerShell:

$env:ENIGMA_BUNDLE="$HOME\.enigma\bundle.json"
enigma-mcp

What does generic MCP client configuration look like?

{
  "mcpServers": {
    "enigma": {
      "command": "enigma-mcp",
      "args": [],
      "env": {
        "ENIGMA_BUNDLE": "/absolute/path/to/.enigma/bundle.json"
      }
    }
  }
}

Which MCP tools are exposed?

  • enigma_init
  • enigma_remember
  • enigma_search
  • enigma_context_pack
  • enigma_delete
  • enigma_verify_receipts

MCP resource and prompt:

  • Resource: enigma://passport/summary
  • Prompt: enigma_standard_memory_prompt

Which connector profiles are supported?

  • claude-desktop
  • cursor
  • kimi-code
  • vscode-cline
  • roo
  • opencode
  • generic-mcp

Connector commands:

enigma doctor
enigma install --bundle "$HOME/.enigma/bundle.json"
enigma connect claude-desktop --bundle "$HOME/.enigma/bundle.json"
enigma connect cursor --bundle "$HOME/.enigma/bundle.json"
enigma connect kimi-code --bundle "$HOME/.enigma/bundle.json"
enigma connect vscode-cline --bundle "$HOME/.enigma/bundle.json"
enigma connect roo --bundle "$HOME/.enigma/bundle.json"
enigma connect opencode --bundle "$HOME/.enigma/bundle.json"
enigma connect generic-mcp --bundle "$HOME/.enigma/bundle.json"

Disconnect one client without touching unrelated settings:

enigma disconnect claude-desktop

Does MCP mean Enigma can control what a model remembers internally?

No. MCP lets Enigma provide scoped context and receive tool calls in supported workflows. It does not prove or control provider-internal memory, hidden logs, model weights, screenshots, exports, or human memory.

Browser extension

What is the browser extension?

The browser extension is an unpacked Manifest V3 scaffold in:

apps/browser-extension

It uses a native messaging host named com.enigma.native_host, never writes raw memory to extension sync storage, and requires an explicit user click before inserting Enigma context into supported provider pages.

What are the development load steps?

  1. Register a native messaging host named com.enigma.native_host in the browser profile.
  2. Point that native host at a local process that can call the Enigma bundle/MCP APIs.
  3. Open the browser extension management page.
  4. Enable developer mode.
  5. Load enigma/apps/browser-extension as an unpacked extension.
  6. Visit a supported provider page and use the Enigma control.

Does the browser extension automatically inject context?

No. It requires explicit user approval before inserting context.

Does the browser extension delete provider-side memories?

No. It cannot delete provider-side memories or force a provider model to forget. It can participate in Enigma-mediated insertion records and receipt metadata where supported.

Desktop

Is there a desktop app?

There is a static local desktop scaffold in:

apps/desktop/src/index.html

Check that the scaffold is present:

cd enigma
node --input-type=module -e "import { readFile } from 'node:fs/promises'; const html = await readFile('apps/desktop/src/index.html', 'utf8'); console.log(html.includes('Enigma Desktop Shell') ? 'desktop scaffold present' : 'desktop scaffold missing');"

Open it locally:

cd enigma
python -m http.server 4173

Then open:

http://127.0.0.1:4173/apps/desktop/src/index.html

If Python is unavailable, open enigma/apps/desktop/src/index.html directly from the filesystem.

Is desktop UI state cryptographic proof?

No. Desktop UI state is operational evidence only. Cryptographic proof comes from Enigma receipts and verifier output.

Enterprise

What is the enterprise value proposition?

Enigma lets enterprises keep durable AI memory under customer-controlled or local-first custody, retrieve only scoped context for each provider/model/tool/agent call, and emit receipts that support audit review, deletion workflows, residency governance, eDiscovery, and policy checks.

Does Enigma guarantee compliance?

No. Enigma provides controls and evidence that can support legal, security, and compliance review. It is not a blanket compliance guarantee or certification by itself.

What deployment modes exist?

Hosted mode:

  • Enigma operator deploys relay/gateway for the tenant.
  • Requires deployment credentials, domain, TLS, KMS/secrets, durable storage, monitoring, backups, and incident response.
  • Tenant policy controls allowed providers, models, regions, purposes, sensitivities, retention, and legal holds.

BYOC mode:

  • Customer deploys relay/gateway in its own cloud, VPC, cluster, or private network.
  • Customer controls deployment credentials, KMS, logs, SIEM export, network policy, backups, and data residency.
  • Enigma package supplies local services and APIs; the customer supplies infrastructure.

What does the gateway do?

The gateway evaluates Enigma enterprise policy and signs decisions. It does not call model providers and does not prove provider deletion or model forgetting.

Run the local gateway demo:

enigma gateway demo

Start the local in-memory gateway HTTP server:

enigma gateway serve --host 127.0.0.1 --port 8797

Health and policy:

curl http://127.0.0.1:8797/health
curl http://127.0.0.1:8797/policy

Evaluate a request by address/metadata, not plaintext:

curl -X POST http://127.0.0.1:8797/gateway/decision \
  -H 'content-type: application/json' \
  --data '{"schema":"enigma.gateway_request.v1","operation":"retrieve","provider":"kimi","model":"kimi-k2","region":"us-east-1","purpose":"support_retrieval","sensitivity":"internal","memory_addr":"addr_committed_memory","memory_id":"mem_allowed","subject_id":"employee_123"}'

Export minimized SIEM evidence:

curl http://127.0.0.1:8797/siem/export

Enigma can support policy-controlled workflows and receipt evidence for Enigma-controlled state. It cannot prove closed-provider deletion, hidden backup deletion, model forgetting, or deletion from systems outside Enigma unless those systems provide independent evidence.

What should enterprise buyers ask in a pilot?

  • Where does canonical memory live?
  • Who controls keys, policy, logs, and deployment credentials?
  • Which providers, models, regions, purposes, and sensitivities are allowed?
  • What exactly do receipts prove?
  • What does the audit bundle exclude?
  • How are support logs redacted?
  • Which hosted, BYOC, or on-prem assumptions apply?
  • What legal and security reviews are still required?

Relay, witness, and gateway network

What is a relay?

A relay is optional infrastructure for storing or routing opaque encrypted records and coordination material. Relays should not receive memory plaintext, prompts, transcripts, or conversation bodies.

Run the local relay demo:

enigma relay demo

Start the local in-memory relay HTTP server:

enigma relay serve --host 127.0.0.1 --port 8787

Health check:

curl http://127.0.0.1:8787/health

Push only an opaque encrypted relay record:

curl -X POST http://127.0.0.1:8787/relay/push \
  -H 'content-type: application/json' \
  --data '{"capsule_id":"cap_local_1","opaque_encrypted_record":"age1-example-ciphertext-only"}'

What should never go to relay endpoints?

Do not send fields such as memory, plaintext, content, text, prompt, transcripts, or conversation bodies to relay endpoints.

What is a witness?

A witness is optional network infrastructure that can attest receipt/proof events, quorum membership, timestamp/slot context, and commitment roots. Witnesses should not access plaintext memory.

What is a checkpoint?

A checkpoint is an opaque commitment, such as a root or batch reference, that can help establish ordering or anchoring for proof/network operations without publishing raw memory.

Can I run relay/gateway in Docker?

From the repository root, build a local image without adding a Dockerfile to the repo:

docker build -t enigma-local -f - . <<'EOF'
FROM node:24-alpine
WORKDIR /app
COPY enigma/package.json ./package.json
COPY enigma/apps ./apps
COPY enigma/packages ./packages
COPY enigma/specs ./specs
ENV NODE_ENV=production
RUN npm install -g .
ENTRYPOINT ["enigma"]
EOF

Run relay:

docker run --rm enigma-local relay demo
docker run --rm -p 8787:8787 enigma-local relay serve --host 0.0.0.0 --port 8787

Run gateway:

docker run --rm enigma-local gateway demo
docker run --rm -p 8797:8797 enigma-local gateway serve --host 0.0.0.0 --port 8797

For production containers, replace in-memory state with durable storage, bind TLS at an ingress layer, mount secrets through the platform, and configure logging/metrics. Do not bake vault bundles or private keys into images.

Privacy and data boundaries

Does Enigma mean nothing ever leaves my device?

No product-wide claim should say that. Enigma has local-only paths, MCP paths, browser/desktop paths, and hosted/BYOC/relay/gateway paths with different boundaries. Always describe the specific deployment mode.

Does Enigma eliminate all side channels?

No. Enigma can provide evidence for instrumented Enigma-mediated operations and reduce unnecessary disclosure through scoped context and encrypted/committed artifacts. It does not prove complete side-channel absence across providers, browsers, operating systems, networks, humans, or uninstrumented tools.

Does Enigma store raw memory on public networks?

No. Raw memory plaintext should not be stored in relay records, witness checkpoints, SIEM events, or public proof artifacts. Public/network artifacts should use commitments, roots, receipt IDs, addresses, and encrypted payloads where appropriate.

Can hashes or commitments leak metadata?

They can. Hashes, commitments, timing, sizes, addresses, and access patterns may reveal metadata. Network and proof artifacts should document these metadata risks.

Who owns or controls memory?

It depends on deployment mode. A personal local vault may be user-controlled. An enterprise vault may be tenant/admin/key controlled. A delegated controller may operate under policy. Do not use a single ownership phrase for every deployment mode.

Can support staff see my memory?

Support should not request raw memory plaintext, private vault contents, credentials, private keys, or customer data. Debugging should use commands, redacted logs, safe receipt metadata, and minimal reproduction steps.

Deletion and tombstones

Can Enigma delete my memory?

Enigma can remove or tombstone Enigma-controlled memory from active serving paths according to the relevant vault and policy behavior. Receipts can show Enigma-mediated delete-request, tombstone, or serving-boundary events.

Does Enigma prove a provider deleted my data?

No. Enigma cannot prove that a closed provider deleted hidden copies, logs, backups, provider-native memory, screenshots, exports, or model weights unless that provider supplies independent evidence that can be verified.

Does Enigma make a model forget?

No. Do not claim model forgetting, semantic forgetting, or weight-level removal. Enigma can control its own vault state and scoped context injection; it cannot prove internal model state changed.

What should we say instead of “delete everywhere”?

Use:

Enigma can emit receipts for Enigma-controlled tombstone/delete-request events and show whether Enigma serving paths continue to include a memory.

Do not use:

Deleted from every provider, erased from the model, forgotten everywhere, or no trace remains.

Before publication, marketing-claims, privacy, security, and terms materials require legal review. Enterprise security/compliance claims require review by qualified internal owners and, where needed, outside counsel.

No. Moderators should provide official boundary copy only and escalate legal/tax/eligibility questions to the designated owner.

Can Enigma claim regulatory compliance?

Only if a specific certification, audit, or legal determination exists and has been approved for publication. Otherwise say Enigma supports governance and audit workflows with evidence.

Can Enigma promise network service availability?

No. Network services may change, pause, fail, or be discontinued. Operator participation, service fees, and governance parameters require published rules and legal/technical review.

Objections

“This sounds like just another AI wrapper.”

Enigma is not a chatbot wrapper. The product surface is memory custody, scoped retrieval, MCP connectivity, receipts, verifier output, browser/desktop integration, enterprise gateway policy, and optional relay/witness/gateway infrastructure.

“Why not just use ChatGPT or Claude memory?”

Provider-native memory can be useful, but it is provider-specific and typically not a portable proof layer. Enigma is designed to keep canonical memory outside any single provider and provide Enigma-mediated receipt evidence.

“Why not just use a vector DB?”

A vector DB can store and retrieve embeddings, but it does not by itself provide a Memory Passport, scoped context boundary, signed lifecycle receipts, offline verifier, MCP installation path, browser/desktop integration, and enterprise/network proof surfaces.

“Why do I need receipts?”

Receipts create portable evidence. They help users and organizations answer what Enigma did: what was created, retrieved, denied, injected, exported, tombstoned, or verified under a stated boundary. They also make failure and tampering visible.

“Can receipts be faked?”

A copied text claim can be faked; a valid receipt must pass verification under the expected schema, signatures, ordering, and bundle context. If a receipt is edited or mismatched, the verifier should reject it.

“Does offline verification mean I never need to trust anyone?”

No. Offline verification reduces reliance on dashboards and services for checking Enigma receipts. It does not eliminate all trust in hardware, operating systems, dependencies, original data entry, policy design, or external providers.

“Is operator compensation promised?”

No. Avoid benefit-promise language. Any operator compensation, if legally and technically approved, should be for verifiable active services under published rules and actual demand.

“Can governance change my private memory?”

No network operator or future governance process can read, seize, or rewrite your private memories. Any optional network governance is bounded to protocol parameters — never private data or company operations.

“Can Enigma freeze or delete my vault?”

Local vault behavior depends on user-controlled files and keys. Hosted or enterprise deployments depend on tenant policy, admin controls, and legal obligations. Do not generalize across deployment modes.

“What if a provider changes its export format or blocks an integration?”

Enigma should preserve source caveats and treat imports as candidates until written through an Enigma vault. Provider changes may affect import completeness, browser workflows, or connector behavior. Enigma cannot guarantee third-party provider support.

“What if MCP clients change?”

Connector profiles may require updates as clients change config paths, schemas, or behavior. Use enigma doctor, connector docs, and public support channels to identify drift.

“Is the browser extension safe?”

The extension requires explicit user approval before insertion and avoids raw memory in extension sync storage. Users should still review what context they insert into provider pages and understand that external provider pages have their own policies and risks.

“Can enterprises use this with zero retention providers?”

Enigma can help keep durable memory outside providers and send only scoped context into provider calls. Whether a provider offers zero/low retention and whether that satisfies enterprise requirements depends on the provider contract, deployment mode, and legal/security review.

“Will Enigma certify us compliant?”

No. Enigma can provide evidence, controls, and architecture patterns that support audits and governance review. Certification or compliance status requires separate review and approval.

“What if I lose my local bundle?”

A local bundle is local state. Users should follow backup and key-management guidance when published. Enigma should not imply it can recover local vault material that the user or tenant has lost without a recovery mechanism.

“Can I share my receipt publicly?”

Only if it contains no private memory plaintext, credentials, customer data, or sensitive metadata. When in doubt, share a redacted verifier screenshot or a sample receipt bundle designed for public use.

“What is the best first action?”

Run the local proof loop, then connect one MCP-capable client:

enigma init --bundle ./.enigma/bundle.json --subject local-user --display-name "Local user"
enigma remember --bundle ./.enigma/bundle.json --text "Prefers concise release notes." --purpose user_memory --tags preference
enigma export --bundle ./.enigma/bundle.json --out ./.enigma/export.json
enigma verify --bundle ./.enigma/export.json

Then:

enigma doctor
enigma install --bundle "$HOME/.enigma/bundle.json"
enigma connect generic-mcp --bundle "$HOME/.enigma/bundle.json"

Note: use the first full quickstart command set above for context-pack generation; keep private memory content out of public support posts.