1. The One-Paragraph Summary
Your conversations, files, memories, skills, and settings are stored in your browser — in IndexedDB and local/session storage. The app does not keep a server-side chat database. Depending on the feature and provider you select, requests and assets can still leave the device:
- Prompts, selected context, and provider authorization headers go to the model service you choose. For some remote providers, the request first passes through the Accelerated Logic server proxy, which forwards it to that provider; a local endpoint may be contacted directly.
- Optional backups you enable go to Google Drive. If you connect Drive, Google returns the account email, which the app stores locally to identify the connected account.
- Browser-local model runtimes and model weights may be downloaded from their configured CDN or model host before inference. Other static assets can also load from third-party CDNs.
2. Where Each Kind of Data Lives
| Data | Stored where | Leaves device? |
|---|---|---|
| Chats, messages | IndexedDB chats store | Only to providers as prompts / optional Drive backup |
| Ingested files | IndexedDB files store | Only when attached to a prompt |
| Memories, skills, agents | IndexedDB stores | Relevant memories and enabled skills may be included in prompts to the selected model; optional backup may send data to Drive |
| Settings | IndexedDB + localStorage mirrors | Secrets stripped before any Drive sync |
| API keys / PATs | Credential store (session + local) | Sent in provider authorization headers; remote requests may transit the app proxy. Encrypted Drive vault is optional. |
| Google Drive token and account email | Token in sessionStorage; connected email in localStorage | Used for Google Drive authentication and to label the connected account; not added to model prompts by this integration |
Storage operations are resilient: if localStorage is unavailable (private/sandboxed contexts), writes fall back to an in-memory store so the app keeps working for that session.
3. How Credentials Are Protected
- One credential chokepoint. All API keys and tokens are read and written through a single
SecretStorehelper rather than scattered rawlocalStoragecalls, so there is one place to audit and harden. - Drive credential backups use a user-held recovery key. The normal settings document still strips every API key. A separate v2 AES-GCM vault backs up provider and fallback keys as ciphertext, but its recovery key is never uploaded to Drive. Save that key to restore a fresh browser profile; the same-profile local cache enables transparent sync and is not XSS protection. Legacy v1 vaults remain readable for migration to a new key, and the old Drive key record is replaced with a non-secret tombstone after upload. Restores only fill blank local credential slots, so an older cloud copy cannot replace a newer local key.
- Local export is redacted by default. The "export database snapshot" action omits secrets unless you explicitly include them; MCP server headers/keys are also stripped.
- Full logout works. Disconnecting GitHub purges the access token from every storage tier and the OAuth refresh token and its expiry; it is not left behind.
- Masked inputs. All key/token fields use
type="password".
Honest limitation: anything in browser storage is reachable by any script executing on the page origin. The real defense against that is strict input sanitization and CSP (below) — there is no evals, no raw HTML rendering of chat, and untrusted code is confined to sandboxed frames. Treat a browser session as you would any logged-in app, and use the clear/revoke controls on shared machines.
4. Sandboxes: Untrusted Code Cannot Touch Your Data
Code generated by agents or pasted by you is never run in the main page:
- Web Sandbox / Code Preview run user code inside
<iframe sandbox="allow-scripts">frames — note there is deliberately noallow-same-origin, so the frame cannot access the parent's storage, cookies, or DOM. - Python runs in Pyodide inside a Web Worker; local LLMs run in Web Workers. Workers have no DOM access and are terminated/revoked when torn down.
- Bridge messages are validated. The parent only accepts messages whose
event.sourceis the exact sandbox frame (and same origin for tool bridges), console payloads are capped in length and count, and any injected HTML in docs runs through DOMPurify with forced iframe sandboxing.
5. Transport & Server Protections
- Content Security Policy restricts scripts to the app origin plus a small set of named hosts, allows WebAssembly via
wasm-unsafe-eval(not blanketunsafe-eval), and limits who can embed the app viaframe-ancestors. - SSRF-hardened proxy. Browser requests are relayed by a small Express server that only forwards to an allowlist of known AI/search domains, blocks private (10/8, 172.16/12, 192.168/16) and link-local (169.254/16) addresses, pins connections to validated IPs to prevent DNS rebinding, and re-checks every redirect target.
- Security headers: HSTS,
X-Content-Type-Options: nosniff,X-Frame-Options, a restrictiveReferrer-PolicyandPermissions-Policy. - OAuth is origin-scoped. GitHub login uses short-lived, cryptographically random session ids/secrets with timing-safe comparison, exact-origin relay checks, 15-minute expiry, and no tokens held server-side. The GitHub client secret is read from environment variables, never the repo.
- Rate limiting is applied to API, auth, proxy, and prompt-enhancement routes; request bodies are capped.
6. Browser-local model inference
With a supported WebLLM, Transformers.js, or Chrome built-in model selected and loaded, inference is performed on the device. Runtime code and model weights may be fetched from a CDN or model host during setup; browser caches can be cleared or evicted. This describes the model inference path, not all network traffic from the website or other connected features.
7. Clearing & Exporting Your Data
Export: Settings → Backup lets you download a full JSON snapshot (secrets optional) or per-slice exports (models, chats, skills, memories).
Clear: "Clear all data" wipes the IndexedDB stores and app-owned local/session keys while deliberately keeping non-content preferences like your theme and EULA acceptance (it does not blindly localStorage.clear() unrelated keys).
Quota handling: if browser storage fills up, the app first evicts regenerable caches and (as a last resort) strips large base64 images from the oldest chats, then retries — your conversation text is preserved.
8. A Threat Model, Plainly Stated
Security claims make sense only against a stated adversary. For this app, three realistic threats and how the design answers them:
Page content, model output, or pasted code tries to run script in the app origin. Answers: no raw HTML rendering of chat, everything through sanitizers with forced iframe sandboxing (allow-scripts, never allow-same-origin for generated code), CSP script-src locked to named hosts, wasm-unsafe-eval only for WASM. The page's own tokens are therefore out of reach of embedded payloads.
The endpoint returns poisoned output trying to exfiltrate data or manipulate agents. Answers: tool-call permission gates, built-in tool server identity checks, prompt-injection shielding tags around untrusted fetched content, and the confirmation card for anything write-class. The residual risk — a model talking you into clicking Keep — is real and is why deletion/creation permissions default to off.
Another user opens the same machine. Answers: credential store scoping, Drive AppData isolation, disconnect flows, purge tooling, and the advice in Section 10. The residual risk — session left open — is procedural, not technical; lock your OS session.
Honest ceiling: none of this protects a fully compromised browser profile (malicious extension, stolen OS account). Browser storage is reachable by any script on the origin — the app minimizes what runs on the origin, but the OS is the trust root.
9. Verify the Claims Yourself — Ten Minutes in DevTools
Privacy docs are cheap talk. Here is the homework to see it with your own eyes:
- Network panel, one prompt. Open DevTools → Network, clear it, send a normal chat message with an equipped cloud model. You will see the app-proxy request (or the provider endpoint) and nothing else conversation-shaped. For Ollama/WebLLM, you should see no model-completion request leave the machine at all.
- Application tab → Storage. Expand IndexedDB: chats, files, memories, settings live here — and nothing lives in a server database you cannot see, because there isn't one. Check localStorage for the settings mirror and sessionStorage for the Drive token.
- Response headers. Reload the page and inspect the document's headers for CSP (script-src with named hosts and wasm-unsafe-eval), HSTS, X-Content-Type-Options: nosniff, Referrer-Policy, and Permissions-Policy.
- Sandbox inspection. Focus a preview iframe (canvas or Web Sandbox), then in the Elements panel confirm
sandbox="allow-scripts"with noallow-same-origin— the technical heart of "generated code cannot read your workspace". - Export audit. Export the workspace snapshot, open the JSON, and search for your key strings — they should be absent (Settings strips them; the separate Drive vault, if enabled, stores only ciphertext).
10. The Shared-Machine Checklist
- Use a private window; nothing to clean afterward, at the price of re-equipping models each visit (Part 3).
- Never connect GitHub or Google Drive on a shared machine — those outlive the window.
- Lock the OS session when stepping away; the app cannot protect an unlocked screen.
- If you forgot and used it on a shared machine: incognito data dies on close, but PATs/keys pasted into the normal profile persist — rotate anything you entered (Section 11).
11. Incident Response — If a Key Leaks
- Revoke the key at the provider first — revoke beats rotate: an invalidated key stops the bleeding immediately even if a copy exists elsewhere.
- Issue a replacement and update it in the Model Organizer / credential store only.
- Check usage/logs — provider dashboards usually show request volume; look for spikes between leak and revoke.
- Purge local copies: remove the key everywhere it was pasted (this app included — credential store, any exported snapshot that might contain it, notes, clipboard managers).
- Sweep snapshots: delete or re-export any workspace snapshot created while the old key was configured; treat old exports as burned.
- Audit the blast radius: if the key had repo or paid scopes, assume misuse — GitHub shows authorized OAuth apps and PATs usage at github.com/settings/tokens; Google shows account permissions at myaccount.google.com.
The 90-second drill: provider revocation page → new key → app update → delete suspicious exports → review provider logs. Everything else is paperwork.