FAQ

Is anything uploaded to the cloud?

No. 13x is local-first: no cloud, no accounts, no analytics, no telemetry, and no network calls, with one optional exception, the signed auto-update check below. Your code, shell output, commands, and every artifact 13x writes stay on your machine. The Code Map references files by path and never uploads their contents; context packets carry references and symbols, not source; checkpoints and audit logs are plain local files.

Does it phone home or send telemetry?

No. There is no telemetry of any kind. The only outbound traffic 13x can make is the auto-update check, which fetches a small JSON manifest and, if an update exists, a signed installer. Nothing about your project, usage, or machine is sent. When you are offline, the app runs unchanged and simply skips the check.

How does context get to agents without uploading my code?

13x builds a local Code Map / Symbol Graph (a graph of files, symbols, and imports) by scanning your repo on disk. When you generate a Context Packet, it selects the most relevant files, symbols, and dependency neighbors and writes a Markdown packet that references them (paths, symbol names, ranking reasons, a suggested inspection order). It does not paste full file contents in V1 (the DEEP budget adds only bounded source excerpts), never calls an external AI API, and never uploads anything. The packet is pasted into your agent terminals locally. No code upload, no external embeddings, no cloud indexing.

Which shells are supported?

PowerShell 7 (pwsh) on every platform. Because pwsh is cross-platform, 13x runs on Windows, macOS, and Linux with the same bootstrap and agent tracking unchanged everywhere. On Windows it falls back to the built-in powershell.exe if pwsh is not present; on macOS and Linux you must install pwsh, and the app surfaces install guidance if it is missing. There is no bash/zsh/cmd selection yet — every slot runs PowerShell.

macOS and Linux PATH note

Apps launched from Finder, Dock, or Spotlight inherit a minimal PATH, so 13x repairs PATH at startup from your login shell (plus Homebrew, Microsoft, and snap dirs) so pwsh and your agent CLIs resolve. A non-standard or very slow (over 3 s) shell profile could still hide a tool — launch 13x from a terminal in that case.

Does it run hidden commands?

No, never. Every startup command lives visibly in the rig (stored as plain JSON) and runs only for slots you explicitly mark auto-start, and only ever in the selected project path. A startup command is typed into the shell exactly as if you had entered it. On resume, every command is shown in the Resume Plan before anything executes, and dangerous commands require explicit confirmation.

Does Broadcast or Relay send commands I can't see?

No. Broadcast types a command you wrote into the live panes you selected — workspace-scoped, never leaking across projects. Relay chains headless agent steps you defined, pausing at every manual checkpoint, with each step's output written to disk for inspection. Both are explicit and visible by design; nothing is injected behind your back.

How are agents tracked?

Through Pulse & Agent Attention, backed by an agent-state watcher reading ground truth from Claude Code hooks. At startup, 13x merges hook entries into your global Claude settings (~/.claude/settings.json) so each hook appends a token to that slot's agent-events.log; foreign hooks and keys are never touched. The backend AgentStateWatcher tails those per-slot logs to derive agent state (prompting, running a tool, waiting for you, stopped). On a turn's Stop event, 13x reads the local Claude transcript (~/.claude/projects/<slug>/<session_id>.jsonl, read-only, last 64 KiB) to surface the real assistant model. The log is cleared on each fresh PTY launch so a new session never replays a dead one's state.

Is agent awareness a guess or ground truth?

Ground truth from the hooks, not output scraping. State comes from the tokens Claude Code writes via its hooks, not from pattern-matching terminal text, which would produce false positives. Where 13x cannot know something statically — for example, Symbol Graph blast radius through dynamic dispatch — it says so rather than guessing.

What happens when 13x crashes or I close it?

Your grid is recoverable. 13x silently checkpoints the rig on launch, on slot start/stop, on kill-all, and every 30 seconds while running, writing .13x/snapshots/latest.json. On restart you get one-click Rig Resume: it restores the rig layout, slots and roles, startup and agent resume commands, redacted last commands, context state, and git checkpoint metadata, then restarts each slot according to its configured Resume Mode (Resume Agent, Rerun Startup, Rerun Last Command, Open Shell Only, or Skip). Resume is checkpoint-based — it does not hibernate OS processes — and it shows a plan before running anything, with Rerun Last Command opt-in and dangerous commands gated behind confirmation. Run history is also reconciled at startup (active runs become interrupted) so Run Logging stays honest after a crash.

Do background workspaces keep running when I switch projects?

Yes. With Workspaces & Sessions you can run several projects at once and switch instantly; nothing in the background ever stops, and a background workspace that needs you raises a needs-you badge. Sessions are isolated per workspace.

Where is my data stored?

Everything is local. Per-project artifacts live under .13x/ in that project; app-level files (rigs, run history, last session) live in the app config directory (<app config dir>/com.thirteenx.desktop/, which is %APPDATA%\com.thirteenx.desktop\ on Windows). Nothing is synced by 13x.

Per-project storage (<project>/.13x/)

• →sessions/<slot>/agent-events.log — append-only Claude Code hook tokens, tailed to derive agent state; cleared on each fresh PTY launch (Pulse).
• →sessions/<slot>/agent-launch.json — per-slot launch marker holding the Claude session id, used for ground-truth model lookup (Pulse).
• →sessions/<slot>/scrollback.txt — redacted terminal scrollback for visual restore (tail, capped at 256 KB, gated by the capture toggle) (Resume).
• →bin/bootstrap.ps1 — generated PowerShell bootstrap used to launch slot shells with agent tracking (The Grid).
• →snapshots/<id>.json, snapshots/latest.json — Rig Checkpoints (layout, slots/roles, redacted commands, context + git metadata, app version) (Resume).
• →snapshots/audit.jsonl — append-only resume audit log (saves, plans, rejected/executed resumes, selected/confirmed slots, failures, version) (Resume).
• →map/codegraph.json, map/last-scan.json — the scanned code map (files, symbols, edges, stats) and a lightweight scan summary (Code Map / Symbol Graph).
• →context-packets/<ts>-<task>.md & .json, usage.json — generated packets (references/symbols, not file contents) plus a versioned local usage log for badge rehydration (Context).
• →relays/runs/<run-id>/run.json, step-NN-output.txt, step-NN-events.jsonl — relay run record, per-step final output, and a debug-only event stream, never a completion signal (Relay).
• →relays/definitions/<id>.json — saved relay definitions (ids restricted to [A-Za-z0-9_-] so they can't traverse out) (Relay).
• →slot-titles.json — manual per-slot task-title overrides (Rigs).
• →decisions.jsonl — append-only Config Advisor decision log (fingerprints + recommended/chosen config; no keys, no model name logged) (Config Advisor).
• →settings.json — optional, hand-edited (e.g. advisorClassifierModel); no API keys are ever stored (Config Advisor).

App config dir (<app config dir>/com.thirteenx.desktop/)

• →rigs.json — all saved rigs as a versioned envelope; corrupt files are moved aside to rigs.corrupt.<ts>.json (Rigs).
• →presets.json — legacy pre-rig presets, migrated into rigs.json on first load (Rigs).
• →runs.json + runs/<run_id>.log — versioned run metadata (capped at 200 closed runs) plus per-run raw ANSI PTY output (Run Logging).
• →last-session.json — the last launched rig and auto-launch / capture toggles, written atomically (Workspaces & Sessions).

Global Claude files (read/merge, never your foreign keys)

• →~/.claude/settings.json — hook entries merged in; foreign hooks and keys are never touched.
• →~/.claude/projects/<slug>/<session_id>.jsonl — transcript, read-only.
• →~/.tauri/ — updater signing keys, used at release time, not by the running app.

What is NOT stored?

13x does not store environment variables or .env contents in Rig Checkpoints. Command fields are secret-redacted before any write (checkpoints, resume plan previews, audit logs), stripping API_KEY/SECRET/TOKEN/PASSWORD=… values, Bearer tokens, and sk-…/ghp_… tokens. Context packets store references and symbols, not file contents. The Config Advisor decision log never records keys or the classifier model name.

Is it enterprise-safe and auditable?

Yes, by construction. Everything runs locally with no telemetry and no hidden commands, so there is no data-exfiltration surface to review. The resume path is explicit and policy-friendly: a Resume Plan previews every command before execution, dangerous commands require per-slot confirmation enforced on both the frontend and the Rust backend (the backend independently re-validates and rejects unconfirmed dangerous slots before stopping any PTY), and every resume attempt is recorded in a local append-only audit log (.13x/snapshots/audit.jsonl). Secrets are redacted before they touch disk, and no environment variables or .env contents are captured. The Tauri capability surface is tight: only core, window-destroy, dialog, updater, and process permissions are granted — no fs/shell/http plugin access is exposed to the webview. The audit and snapshot files are plain files 13x does not sync, so retention, backup, and policy enforcement can be layered on by your host without changing PTY behavior.

Are auto-updates trustworthy?

Updates are cryptographically signed (minisign), and the app verifies the signature against an embedded public key before installing — an unsigned or tampered payload is rejected. Network traffic is manifest-only, there is no telemetry, and the app is never disrupted when offline.