# 08 — Press Kit

Publication status: launch-ready draft. Token-related language requires board and legal review before publication.

## Press kit index

1. Company boilerplate
2. Launch announcement
3. Founder quote drafts
4. Media FAQ
5. Product screenshot list
6. Demo script
7. Analyst briefing notes
8. Claim boundaries for media
9. Approved links and install commands

## Company boilerplate

### One-sentence boilerplate

Enigma is the memory card for AI: provider-neutral memory/proof infrastructure for portable context, local-first custody, scoped model use, and offline-verifiable receipts.

### Short boilerplate

Enigma builds provider-neutral AI memory/proof infrastructure. Its Memory Passport gives users and organizations a portable way to carry Enigma-managed context across AI tools, while local-first and customer-controlled vaults keep durable memory outside any single model provider. Enigma emits signed receipts for declared Enigma-mediated memory lifecycle and boundary events so users, developers, and enterprises can verify what happened inside Enigma’s declared boundary.

### Standard boilerplate

Enigma is building the verifiable memory plane for AI. The company gives people, developers, and enterprises a provider-neutral Memory Passport for AI context, local-first or customer-controlled vaults, scoped context injection into model and tool calls, and signed receipts for Enigma-mediated memory lifecycle and boundary events. Enigma works through CLI, MCP, connector profiles, importers, browser and desktop scaffolds, relay, gateway, and enterprise policy surfaces. Its optional network roadmap focuses on encrypted relay, opaque checkpoint witnessing, gateway access, and bounded governance; raw memories are not intended to be stored on-chain. Token-related materials require legal review and must be framed only as utility, governance, and network access, not equity, revenue share, or financial upside.

### Category statement

AI is shifting from sessions to relationships. Enigma makes those relationships portable and accountable by separating durable AI memory from any single provider and attaching receipts to Enigma-mediated memory operations.

## Launch announcement

### Headline options

1. Enigma launches the memory card for AI
2. Enigma introduces portable, verifiable memory for AI agents
3. Enigma unveils provider-neutral AI memory with offline-verifiable receipts
4. Enigma brings Memory Passports and proof receipts to AI workflows

### Recommended headline

Enigma launches the memory card for AI

### Subheadline

New provider-neutral memory/proof infrastructure helps users, developers, and enterprises carry AI context across tools, keep custody local or customer-controlled, and verify Enigma-mediated memory events with signed receipts.

### Dateline

SAN FRANCISCO — Board/legal-review required recommended dateline.

### Announcement body

Enigma today announced provider-neutral AI memory/proof infrastructure designed to make AI memory portable, governed, and verifiable. Enigma gives users and organizations a Memory Passport for durable AI context, a local-first or customer-controlled vault for custody, scoped retrieval for model and tool calls, and signed receipts for declared Enigma-mediated memory lifecycle and boundary events.

As AI tools move from one-off chat sessions to persistent agents and long-running workflows, memory is becoming core infrastructure. But today, memory often remains trapped inside individual model providers, chat products, vector databases, agent stacks, or team-specific tools. Users lose continuity when they switch tools. Developers rebuild memory systems for every agent. Enterprises need evidence about what was remembered, retrieved, denied, exported, or tombstoned inside their policy boundary.

Enigma addresses that gap by acting as a neutral memory layer beneath AI clients and providers. A user can create a local vault, write memory, compile a scoped context pack, export a proof bundle, and verify receipts offline. Developers can connect MCP-capable agents through `enigma-mcp` and use Enigma tools for memory initialization, recall, context-pack creation, deletion from Enigma active serving, and receipt verification. Enterprise teams can evaluate customer-controlled deployment paths, gateway policy decisions, minimized SIEM evidence, and proof bundles that support governance and audit workflows.

The launch includes CLI, verifier, vault, passport, boundary, MCP server, connector, importer, relay, gateway, enterprise, mesh, browser-extension, and desktop scaffold code in the repository. Enigma does not claim that a closed provider deleted internal data, that model weights forgot, or that provider-native memory disappeared. Its receipts prove facts about Enigma-controlled vault state, receipt chains, checkpoints, context packs, and declared boundary operations.

Enigma’s optional network roadmap includes relay, witness, and gateway roles for encrypted capsule relay, opaque checkpoint witnessing, access coordination, and bounded protocol governance. Raw memories, prompts, transcripts, embeddings, private ACLs, and personal metadata should not be written on-chain by default. Any Solana utility-token plan remains subject to legal review and must be framed as utility, governance, and network access only, not equity, revenue share, company ownership, ownership of user data, or a promise of financial return.

### Launch proof paragraph

A first local proof loop can be completed from a checkout: install Enigma, initialize a local vault bundle, write one memory, produce a context pack, export a proof bundle, and run the verifier. This shows the core product promise in one sequence: portable local memory plus verifiable Enigma-mediated evidence.

### Launch CTA paragraph

Developers and early users can start with the local install path, connect an MCP-capable client, and verify their first receipt. Enterprise teams can request a private pilot focused on custody, gateway policy decisions, minimized evidence export, and proof boundaries.

## Founder quote drafts

Final speaker names and titles require founder approval before publication.

### Quote 1 — category

“AI is moving from sessions to relationships, and relationships need memory. The problem is that memory is becoming trapped inside individual apps and providers. Enigma is the memory card for AI: a portable, provider-neutral layer that helps people carry context and verify what happened inside the memory boundary.”

Recommended attribution: Founder & CEO, Enigma. Board/legal-review required speaker/title.

### Quote 2 — trust and proof

“Trust in AI memory cannot just be a dashboard. Enigma receipts are designed to be exported, inspected, and verified offline, so a user, developer, or auditor can check declared Enigma-mediated operations without relying on a model provider’s internal state.”

Recommended attribution: Founder & CTO, Enigma. Board/legal-review required speaker/title.

### Quote 3 — enterprise

“Enterprises want AI systems that remember, but they also need policy, custody, deletion workflows, and evidence. Enigma keeps durable memory under local-first or customer-controlled custody and sends providers only scoped context for the workflow.”

Recommended attribution: Founder & CEO, Enigma. Board/legal-review required speaker/title.

### Quote 4 — developer

“Developers should not have to rebuild memory custody, imports, policy boundaries, and receipt verification for every agent. Enigma gives builders a provider-neutral memory/proof layer they can connect through MCP.”

Recommended attribution: Founder & Head of Developer Relations, Enigma. Board/legal-review required speaker/title.

### Quote 5 — network and token boundary

“The optional network is about useful infrastructure: encrypted relay, opaque witnessing, gateway access, and bounded governance. Local Enigma works without token ownership, and any token plan must stay utility-focused, legally reviewed, and separate from ownership or financial-upside claims.”

Recommended attribution: Founder & CEO, Enigma. Board/legal-review required speaker/title.

## Media FAQ

### 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, and signed receipts for declared Enigma-mediated memory lifecycle and boundary events.

### Why does AI need a memory card?

AI tools are becoming persistent assistants and agents. Their memory should not be trapped in one app, subscription, model provider, or vector store. The memory-card analogy explains Enigma’s role: portable, trusted storage and proof beneath many AI tools, not another chatbot.

### What is a Memory Passport?

A Memory Passport is a portable package of Enigma-managed AI context and receipt history that can move across supported clients and workflows. It lets Enigma act as the durable memory layer while providers and clients remain interchangeable.

### What is a receipt?

A receipt is a signed, hash-linked record of an Enigma-mediated event. Examples include memory creation, retrieval, context-pack creation, export, tombstone, delete-request, boundary decision, relay record, and witness checkpoint.

### What can receipts prove?

Receipts can prove that declared Enigma-mediated operations were signed, ordered, and committed under a stated policy boundary. They can support evidence about Enigma-controlled vault state, context-pack creation, gateway decisions, and checkpoint commitments.

### What can receipts not prove?

Receipts do not prove factual truth, model intent, model reasoning, complete provider deletion, model forgetting, semantic forgetting, or complete absence of uninstrumented side channels. They also do not prove that external providers, backups, screenshots, logs, or people deleted information unless those systems provide independent evidence.

### Is Enigma a chatbot?

No. Enigma is infrastructure beneath AI tools. It connects through CLI, MCP, connector profiles, importers, browser and desktop scaffolds, relay, gateway, and enterprise surfaces.

### Is Enigma a vector database?

No. Retrieval may be part of memory workflows, but Enigma’s category is memory custody, portability, policy, and proof. It can wrap or integrate with existing memory and retrieval systems.

### Does Enigma replace model providers?

No. Enigma is provider-neutral. It is designed to work across model providers, clients, local models, agent frameworks, and enterprise gateways.

### Does Enigma delete memories from ChatGPT, Claude, or other providers?

No. Enigma can tombstone or remove memory from Enigma active serving state and produce receipts for Enigma-controlled transitions. It cannot prove deletion from closed provider internals, hidden logs, caches, backups, model weights, screenshots, or people.

### Does Enigma store memories on Solana?

No. Raw memories, prompts, transcripts, embeddings, private ACLs, and personal metadata should not be written on-chain by default. Optional network infrastructure may use opaque roots, commitments, receipt IDs, operator records, and service metadata where useful.

### Is there a token?

Enigma has a Solana utility-token plan for optional relay, witness, and gateway network coordination, subject to legal review. The token, if launched, is intended for utility, governance, and network access. It is not equity, not a revenue share, not a claim on company assets or user data, and not marketed with any expectation of profit.

### Do users need a token to use Enigma locally?

No. Local memory, MCP use, export, and offline receipt verification should work without token ownership.

### Why Solana?

Solana provides established token primitives and public-network infrastructure that may be useful for operator coordination, service settlement, opaque checkpoint anchoring, and governance. Local Enigma and offline receipt verification do not depend on Solana for every use.

### What Solana token design will Enigma use?

Recommended draft value requiring board/legal review: use a simple base token design unless a specific Token-2022 extension is needed at launch. SPL tokens use Mint Accounts and Token Accounts. Token-2022 adds optional extensions; most extensions must be planned at mint creation. MetadataPointer and TokenMetadata can store canonical name, symbol, URI, update authority, and custom metadata on the mint. Final program choice, authorities, addresses, extensions, and publication language require engineering, board, and legal approval.

### Who is Enigma for first?

Enigma is for AI power users who want memory portability, developers building MCP-capable agents, enterprises evaluating controlled AI memory, and infrastructure participants interested in relay, witness, and gateway roles.

### What is available now?

The repository includes local production foundation and package scaffolding for CLI, verifier, vault, passport, boundary, MCP server, connector, importer, relay, gateway, enterprise, mesh, browser-extension, and desktop scaffold surfaces. Hosted cloud operation requires deployment credentials, domain, TLS, durable storage, KMS or secrets, monitoring, and operator policy.

## Product screenshots list

These are screenshot targets for launch pages, press folders, analyst decks, and social previews. Capture real UI or terminal output before publication; do not mock verifier results.

### Core product screenshots

1. Homepage hero — “The memory card for AI” with install and receipt CTAs.
2. Local CLI install — terminal showing `enigma --help` after repository install.
3. Local vault initialization — terminal showing `enigma init --bundle ./.enigma/bundle.json --subject local-user --display-name "Local user"`.
4. First memory write — terminal showing `enigma remember` with a non-sensitive example preference.
5. Context pack creation — terminal showing `enigma context` writing `./.enigma/context-pack.json`.
6. Proof export — terminal showing `enigma export --bundle ./.enigma/bundle.json --out ./.enigma/export.json`.
7. Offline verification — terminal showing `enigma verify --bundle ./.enigma/export.json` with a successful verifier result.
8. Receipt detail view — UI or JSON viewer showing receipt ID, event type, signature status, policy hash, and timestamp or ordering field without raw private memory.
9. Memory Passport summary — MCP resource or UI panel for `enigma://passport/summary`.
10. MCP client config — JSON block showing the universal `enigma-mcp` entry with `ENIGMA_BUNDLE`.

### Developer screenshots

11. MCP tools list — view showing `enigma_init`, `enigma_remember`, `enigma_search`, `enigma_context_pack`, `enigma_delete`, and `enigma_verify_receipts`.
12. Connector CLI — terminal showing `enigma connect cursor --bundle "$HOME/.enigma/bundle.json"` or another supported client.
13. Importer demo — terminal showing the importer API demo output with source caveats and completeness flags.
14. Receipt tamper failure — verifier rejecting a modified proof bundle.
15. Relay demo — terminal showing `enigma relay demo`.
16. Gateway demo — terminal showing `enigma gateway demo`.

### Enterprise screenshots

17. Gateway policy endpoint — terminal or UI showing policy metadata without sensitive payloads.
18. Gateway decision request — example request using `memory_addr`, `memory_id`, provider, model, region, purpose, and sensitivity, not plaintext memory.
19. SIEM export — minimized evidence export view.
20. Deployment modes graphic — hosted, BYOC, VPC, on-prem, and local evaluation paths.
21. Proof boundary slide — what receipts prove and what they do not prove.

### Network screenshots

22. Relay record diagram — opaque encrypted record only.
23. Witness checkpoint diagram — commitments and roots, not memory plaintext.
24. Operator roles page — user, builder, relay, witness, gateway.
25. Token utility boundary card — utility, governance, network access, and explicit non-equity language.

## Demo script

### Demo title

The 60-second trust loop: local memory plus offline proof

### Audience

Users, developers, enterprise evaluators, press, and analysts.

### Objective

Show Enigma as provider-neutral AI memory/proof infrastructure in one concrete flow: install, create memory, retrieve scoped context, export proof, verify receipt, explain boundaries.

### Script

#### 0:00–0:10 — Set the problem

Narration: “AI is becoming stateful, but memory is trapped inside apps and providers. Enigma is the memory card for AI: portable context with receipts you can verify.”

Visual: Homepage hero or terminal prompt in the Enigma directory.

#### 0:10–0:20 — Install and initialize

Narration: “Start from the local path. No hosted Enigma service is required for this demo after the checkout or package is available.”

Commands:

```sh
cd enigma
npm install -g .
mkdir -p .enigma
enigma init --bundle ./.enigma/bundle.json --subject local-user --display-name "Local user"
```

#### 0:20–0:30 — Write memory

Narration: “Write one non-sensitive memory into the local vault. This becomes Enigma-managed memory, not provider-native memory.”

Command:

```sh
enigma remember --bundle ./.enigma/bundle.json --text "Prefers concise technical answers." --purpose user_memory --tags preference
```

#### 0:30–0:40 — Create scoped context

Narration: “An agent can ask Enigma for only the context needed for a task.”

Command:

```sh
enigma context --bundle ./.enigma/bundle.json --query "technical answers" --purpose local_context --out ./.enigma/context-pack.json
```

#### 0:40–0:50 — Export and verify

Narration: “Now export the proof bundle and verify the receipts offline.”

Commands:

```sh
enigma export --bundle ./.enigma/bundle.json --out ./.enigma/export.json
enigma verify --bundle ./.enigma/export.json
```

#### 0:50–1:00 — Explain proof boundary

Narration: “The receipt proves declared Enigma-mediated operations inside the Enigma boundary. It does not prove the memory is factually true, what a model intended, or that an external provider deleted hidden state.”

Visual: Proof boundary slide.

### Five-minute developer demo extension

1. Show the universal MCP entry:

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

2. Start the server:

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

3. Explain the MCP tools:

- `enigma_init`
- `enigma_remember`
- `enigma_search`
- `enigma_context_pack`
- `enigma_delete`
- `enigma_verify_receipts`

4. Connect one client:

```sh
enigma connect cursor --bundle "$HOME/.enigma/bundle.json"
```

5. Show a receipt and verifier result.

### Five-minute enterprise demo extension

1. Run gateway demo:

```sh
enigma gateway demo
```

2. Start gateway server:

```sh
enigma gateway serve --host 127.0.0.1 --port 8797
```

3. Show health and policy:

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

4. Evaluate a policy decision by address and metadata, not plaintext:

```sh
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"}'
```

5. Export minimized SIEM evidence:

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

6. Close with boundary: the gateway evaluates Enigma enterprise policy and signs decisions; it does not call model providers and does not prove provider deletion or model forgetting.

## Analyst briefing notes

### Briefing objective

Position Enigma as the provider-neutral AI memory/proof layer: a SanDisk-like substrate for AI relationships, not a chatbot, not a foundation model, not just a vector database, and not a token-first project.

### Analyst thesis

AI applications are becoming stateful. The winning memory layer will be portable across providers, governed by policy, usable by developers, inspectable by enterprises, and verifiable outside any single vendor dashboard. Enigma is building that layer through Memory Passports, local-first and customer-controlled vaults, scoped context packs, signed receipts, and optional relay/witness/gateway network infrastructure.

### Category frame

- Category: Verifiable AI Memory Infrastructure
- Consumer phrase: The memory card for AI
- Developer phrase: Provider-neutral memory and proof for every AI runtime
- Enterprise phrase: Customer-controlled AI memory control plane with offline-verifiable lifecycle and boundary receipts

### Why now

- AI products are adding native memory, making lock-in visible.
- MCP and agent frameworks make memory and tool boundaries programmable.
- Enterprises are moving from pilots to governed AI programs and need evidence, not only policy documents.
- Provider-neutral model routing is becoming normal; provider-neutral memory is the missing adjacent layer.

### Product architecture in one flow

1. Vault: local-first or customer-controlled canonical memory.
2. Memory Passport: portable context package and receipt history.
3. Policy: purpose, sensitivity, subject, region, provider, model, and key boundaries.
4. Retrieval: scoped context for a task.
5. Boundary: model, tool, provider, relay, witness, or gateway event.
6. Receipt: signed and hash-linked record of the Enigma-mediated event.
7. Verifier: offline check of the proof bundle.
8. Optional network: encrypted relay, opaque witnessing, gateway coordination, and bounded governance.

### What is differentiated

- Enigma is provider-neutral rather than tied to one model subscription.
- Enigma treats memory as custody plus proof, not only recall.
- Enigma supports MCP installability for developers.
- Enigma can wrap existing memory systems, importers, gateways, and observability tools rather than forcing a rip-and-replace.
- Enigma is explicit about proof boundaries and does not claim external-provider deletion or model forgetting.

### Target segments

1. AI power users: portable personal AI memory.
2. Developers: MCP memory API and receipts for agents.
3. Enterprises: auditable memory control plane with customer-controlled deployments.
4. Ecosystem partners: memory engines, model gateways, and tools that want proof-carrying memory.
5. Network operators: relay, witness, and gateway roles after legal and technical readiness.

### Business model draft

Recommended draft value requiring board/legal review:

- Free: local vault, CLI, MCP server, verifier, limited connectors.
- Pro: desktop app, encrypted sync, browser extension premium features, multi-device backup, advanced imports, receipt explorer.
- Developer: SDKs, hosted relay quotas, team capsules, app integration keys, verification API.
- Enterprise: gateway, BYOC/VPC/on-prem, SSO/SCIM, KMS/BYOK, SIEM/eDiscovery, legal hold, admin policy, support/SLA.
- Ecosystem: Enigma Passport Compatible certification, vendor verification suite, partner marketplace for importers and connectors, witness network participation.

Final plan, packaging, and claims require board/legal review before publication. Do not use financial-upside, resale, trading, scarcity, or guaranteed-compensation framing.

### Token posture for analysts

The token is not the product center of gravity. Local Enigma works without token ownership. The planned Solana token, if launched after legal review, is intended for utility, governance, and network access within optional relay, witness, and gateway infrastructure. It is not equity, not a revenue share, not a claim on company assets or user data, and not marketed with any expectation of profit.

Potential utility surfaces:

- Service settlement for relay, witness, gateway, anchoring, and access paths.
- Operator bonding for active network service under published rules.
- Bounded governance over protocol parameters, fee bands, schema upgrades, witness criteria, grants, verifier requirements, and operator rules.
- Ecosystem grants and service subsidies for verified contribution, not passive holding.

Solana implementation facts:

- SPL tokens use Mint Accounts and Token Accounts.
- Token-2022 adds optional extensions.
- Most extensions must be planned at mint creation.
- MetadataPointer points to metadata, and TokenMetadata can store name, symbol, URI, update authority, and custom metadata on the mint.
- Final design, authorities, addresses, extensions, and legal language require technical, board, and legal approval before publication.

### Proof boundary for analysts

Receipts prove declared Enigma-mediated operations were signed, ordered, and committed under a stated policy boundary. They do not prove factual truth, model intent, model reasoning, complete provider deletion, model forgetting, semantic forgetting, compliance outcomes, or complete absence of uninstrumented side channels.

### Competitive landscape frame

Provider-native memory: convenient but provider-scoped.

Vector databases: retrieval infrastructure, not full custody/proof.

Agent observability: tracing and debugging, not necessarily portable signed memory receipts.

Model gateways: provider policy and routing, not necessarily durable memory passports.

Blockchains: useful for coordination and opaque commitments in some network paths, not a place to store raw AI memory.

Enigma’s angle: neutral memory custody and proof across those categories.

### Analyst questions to prepare for

1. What is the first must-have user workflow?
2. What proves Enigma is more than a memory wrapper?
3. How does Enigma avoid provider deletion overclaiming?
4. What parts are open protocol versus paid product?
5. How does MCP distribution change adoption?
6. What exactly is in a receipt?
7. What does the verifier check offline?
8. How will enterprises deploy this without token custody?
9. What Solana features are required at launch, if any?
10. How does the company prevent token speculation from overwhelming product messaging?

### Suggested closing line

Enigma is not asking the market to believe AI memory should be another app feature. It is betting that memory becomes infrastructure: portable like storage, governed like enterprise data, and verifiable like a receipt.

## Claim boundaries for media

**Standard proof boundary:** Enigma proves Enigma-mediated vault state, receipts, checkpoints, context packs, and declared boundary operations; it does not prove external provider internals, provider-native deletion, hidden logs/caches/backups, model forgetting, or factual truth.

Approved:

- Enigma is provider-neutral AI memory/proof infrastructure.
- Enigma gives users and organizations portable Memory Passports.
- Enigma supports local-first custody for the local path and customer-controlled enterprise deployment modes.
- Enigma emits signed receipts for declared Enigma-mediated memory lifecycle and boundary events.
- Receipts can be verified offline.
- Enigma can wrap or integrate with existing memory systems and model workflows.
- Optional network infrastructure focuses on encrypted relay, opaque checkpoint witnessing, gateway access, and bounded governance.

Not approved:

- Enigma proves provider deletion.
- Enigma proves model forgetting.
- Enigma proves complete absence of side channels.
- Enigma stores raw memories on-chain.
- Enigma guarantees compliance outcomes.
- Token ownership is equity, revenue share, company ownership, or ownership of user data.
- Token materials include financial-upside, resale, trading, scarcity, listing, burn-value, payment-for-mere-holding, guaranteed-compensation, or company-ownership language.

## Approved links and install commands

Final public URLs require board/legal-review approval before publication. Recommended draft values:

- Website: `https://enigma.ai` — board/legal-review required recommended URL.
- Docs: `https://docs.enigma.ai` — board/legal-review required recommended URL.
- Community: `https://community.enigma.ai` — board/legal-review required recommended URL.
- Security contact: `security@enigma.ai` — board/legal-review required recommended address.
- Press contact: `press@enigma.ai` — board/legal-review required recommended address.

### Repository install

```sh
cd enigma
npm install -g .
enigma --help
```

### Local proof loop

```sh
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
```

### MCP server

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

### Generic MCP client entry

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