Trust & Security

MemStrata is a local-first tool. This page is the authoritative list of what runs locally and what crosses the network. If something isn’t on the “leaves your machine” list, it doesn’t leave.

What stays local

Everything that makes MemStrata useful never leaves your machine:

Your source code. The full codebase graph, AST index, and symbol database are stored in a local SQLite file at ~/memstrata/index.db. Nothing is synced to any server.
Your AI prompts. Requests you send to Claude, GPT-4, Ollama, or any other provider flow from your AI tool → MemStrata harness (localhost:8080) → your chosen provider directly. MemStrata reads prompts to compress them; it does not log or forward them.
AI responses. Responses from your provider pass back through the harness for token counting. They are not stored server-side.
Your developer profile. Edit history, retrieval recall scores, session data, and the four dashboard metrics are written to a local DuckDB file at ~/memstrata/telemetry.db.
API keys. Provider keys (OpenAI, Anthropic, etc.) are stored in your OS keychain (Keychain Access on macOS, Windows Credential Manager on Windows, libsecret on Linux). MemStrata never writes them to disk in plaintext.
Browser extension captures. Text captured from AI chat interfaces (Claude.ai, ChatGPT, etc.) is processed locally by the extension and sent to the local harness. It does not route through any MemStrata server.

What leaves your machine

The only data that leaves your machine is the minimum required to verify your subscription:

License JWT (on every startup)

MemStrata sends a signed JWT to memstrata.dev/lic to verify your subscription status. The JWT contains:

A subscription ID (opaque string, not your email)
A hardware ID hash (HMAC-SHA256 of your machine fingerprint, salted per license — not a raw hardware ID)
Expiry timestamp

The JWT contains no code, no prompts, no file paths, no personal identifiers. The license server responds with a validity confirmation and returns nothing else. Verification uses a short-lived token; your machine fingerprint is never stored on our servers in recoverable form.

Optional: anonymous detection blackout events

If the browser extension fails to capture a session (e.g., the AI provider changed their DOM structure), MemStrata can report a detection_blackout event containing:

The provider name (e.g., claude.ai)
A timestamp

No message content, no user identity. This is opt-out — disable it in Settings → Privacy → “Report capture failures.”

Architecture summary

┌──────────────────────────────────────────────────────────────┐
│                    Your machine — all local                   │
│                                                               │
│   AI tool ──▶  MemStrata harness ──▶  Your LLM provider      │
│   (Claude Code,   (localhost:8080,       (Anthropic, OpenAI, │
│    Cursor, etc.)   reads + compresses)    Ollama, etc.)       │
│                         │                                     │
│                         ▼                                     │
│                 Local SQLite + DuckDB                         │
│                 (index.db + telemetry.db)                     │
│                                                               │
└──────────────────────────────────────────────────────────────┘
                         │
                         │ signed JWT only (no code, no prompts)
                         ▼
                 ┌─────────────────────┐
                 │ License server      │
                 │ memstrata.dev/lic   │
                 └─────────────────────┘

Money-back guarantee

The money-back guarantee is enforced mechanically, not on a case-by-case basis.

At the end of each billing cycle, the MemStrata client computes your total measured savings from ~/memstrata/telemetry.db. If your savings are less than your subscription cost, MemStrata submits a Stripe credit note for the difference automatically. The credit appears on your next invoice; you don’t need to file a request.

Scope: Measured savings = (tokens saved vs. baseline) × your provider’s per-token rate, summed over the billing cycle. The baseline is the median token count for your cohort using naive RAG on equivalent codebases.

What counts: Only cycles where MemStrata was active for ≥7 days. If you didn’t use MemStrata in a given cycle, no charge is generated (Stripe trial/pause mechanics apply).

Full policy text: Money-back Policy

Contact

Security issues: security@memstrata.dev (PGP key on the GitHub repo).

Data deletion: email privacy@memstrata.dev with your subscription ID. We’ll confirm deletion within 48 hours (there’s very little server-side data to delete).