# The ThunderGate User Guide

**Your own AI agent. On your hardware. Working for you.**

*For ThunderGate 1.2.4. This guide covers every corner of ThunderGate from the owner's seat:
what your agent can do, how to ask for it, and the guarantees that hold the whole time.*

---

## How to read this guide

You don't need to read it front to back. The single most useful thing to know is this:

> **Just ask.** Your agent knows its own capabilities. "What can you do?" gets a real answer,
> grounded in what's actually switched on for *your* installation — not a brochure.

Everything below is the longhand version, for when you want the map.

A note on how you'll drive it: almost everything in ThunderGate is done **in conversation** —
you ask in plain language, on whatever channel you like. A small set of things (installation,
starting and stopping, vault administration) are done at the **command line** with the
`thundergate` command on the machine where your agent lives. This guide marks which is which.

---

## 1. The first hour

### Setting up a new agent

On the machine that will host your agent, run:

```
thundergate setup
```

The wizard walks you through everything, one step at a time:

- **Identity** — your agent's name and role.
- **AI keys** — the model provider key(s) your agent thinks with.
- **Channels** — connect Slack, WhatsApp, email, Telegram, or others (each optional; add more later).
- **Vault** — choose the passwords for your agent's two vaults (explained in section 6).
- **Fleet** — if you'll run more than one agent, how they find each other (skippable).

Then `thundergate start` and say hello on any channel you connected.

### Bringing an existing agent with you

If you already have an agent from an earlier runtime, don't start over — migrate:

```
thundergate migrate
```

Migration carries your agent's identity, memories, workspace files, and scheduled tasks across,
and — new in 1.2.4 — **verifies the move section by section against the source**. If anything
didn't carry, migration tells you loudly rather than letting your agent quietly forget.

### Meet your agent: the Tour

When you're new, your agent introduces itself. If the Tour is enabled, it will occasionally
mention something it can do for you — *"Did you know I can watch your inbox? Or hold your
vault?"* — always at a natural moment, never as a lecture. The very first tip tells you how to
turn tips off, and a single "quit it" ends them instantly and permanently. As you settle in,
the introductions taper off on their own; after that, it simply answers when you ask.

Ask anytime: **"What can you do?"** — the answer comes from your live configuration, so it
never promises something that isn't actually turned on for you.

---

## 2. Talking to your agent

Your agent holds **one conversation across every surface**. Start a topic on Slack in the
morning, continue it on WhatsApp from the road, finish it at the terminal that night — it's
the same agent with the same memory of the same thread of your life.

| Surface | What it's like |
|---|---|
| **Slack** | Full conversation in DMs or channels; threads stay threaded, files and screenshots flow both ways, and it can react with emoji like anyone else on the team. |
| **WhatsApp** | Conversation on your phone; rich text and images. In group chats it reads along for context but speaks only when spoken to. |
| **Telegram** | Direct chat via your bot; it can also send messages to your saved contacts by name when you ask. |
| **Email** | Your agent reads and writes email as a first-class citizen — see "Email" below. |
| **Discord** | Channel conversation, mention-gated. |
| **ThunderCommo** | The Thunder-native channel: direct agent-to-agent and family messaging, including **voice notes** — send one and your agent hears it (it's transcribed on your own hardware). Family mode lets a household's agents share appropriate context. |
| **The terminal (TUI)** | `thundergate tui` opens a live cockpit on the agent's machine: chat pane, an optional live browser pane beside it, and a status bar showing model, context usage, and uptime. Great for watching your agent work. |

**Voice**: with voice enabled, your agent can listen (speech-to-text) and speak (text-to-speech)
on supported channels. Ask it to turn its voice on or off.

**Reaching out to you**: with your standing permission, your agent can start a conversation —
a heads-up, a reminder landing, something it noticed. You control whether that's allowed at
all, how eager it should be, and your quiet hours. Say "don't message me first after 9pm"
and it's done.

---

## 3. What you can ask for

This is the everyday heart of ThunderGate. Everything here is asked for in plain language.

### The web

Your agent browses the real web through **ThunderBrowser** — its own browser, acting under
the access *you've* delegated to it.

- **"Find out X"** — it searches the web (several search providers supported), opens pages,
  reads them, and brings back an answer with its sources.
- **"Go to my account on X and check Y"** — it navigates, logs in with credentials from the
  vault (see section 6 — it uses them without ever seeing them), and does the legwork.
- **"Fill out this form"** — it works through forms like a careful human: field by field,
  natural pacing.
- **"Watch this page until the price drops"** — it can watch a page for a condition and tell
  you when it's met.
- **"Show me"** — it takes a screenshot of what it's looking at and posts it to your chat.
- In the TUI's split view, or with the browser window shown, **you can literally watch the
  pointer move** as it works.

**The guardrails, always on:**

- It will **never** solve a CAPTCHA, security code, or login challenge. Those come back to
  you, every time, by design.
- It **stops before the point of no return**. Submit, Pay, Purchase, Book, Confirm — buttons
  like these are never clicked without asking you first.
- Everything it does in the browser is written to an **audit trail you can ask for**:
  "show me what you did in the browser today."

### Email

- **"Any mail from the county this week?"** — reads and searches your inbox (Gmail and
  iCloud supported).
- **"Reply and tell them Thursday works"** — composes the reply in-thread, shows you, and
  **sends only after you confirm**. New outbound mail works the same way: nothing is sent
  without your say-so.
- **Drafts** — it can keep a draft going with you across several rounds before sending.
- **"What did I send her last month?"** — it can check the sent folder too.
- **"Keep an eye on my inbox"** — with the heartbeat enabled (section 8), it watches for
  things worth telling you about.

### Calendar

- **"What's my week look like?"** — reads your calendar (iCloud and Google Calendar both
  supported; Google has a one-time guided setup — just ask "set up my Google calendar").
- Your agent also uses the calendar quietly for context: it knows a trip is coming and reads
  the room accordingly.

### Files and documents on its machine

Your agent can read, write, and organize files in its own workspace — ask it to save notes,
draft documents, keep running logs, or dig something out of a folder you've shared with it.
(Credential files are off-limits to these tools by construction.)

### Reminders and scheduled work

- **"Remind me Friday at 3 to call the bank."**
- **"Every morning at 7, give me weather and my first meeting."**
- **"Check the shipment status every 4 hours until it arrives."**

One-time, daily, or every-N-interval — your agent manages its own schedule. Ask "what do you
have scheduled?" to see everything pending, and tell it to drop anything you're done with.
The same works from the command line: `thundergate cron list` / `add` / `remove`.

### Bigger jobs

- **Heads-down mode** — for long multi-step work, your agent can drop into a focused mode:
  it posts progress as it goes instead of going quiet, and surfaces when it's done or needs
  you. It enters this mode on its own for big jobs, or you can say "heads down on this."
- **Second opinions** — it can consult another model ("ask GPT what it thinks of this plan")
  and bring the answer back, labeled as such.
- **Delegation** — it can spin up a short-lived helper for a focused side task, or hand a
  heavy engineering job to a background worker and let you both get on with your day; it
  tells you when the result lands.

### Everyday helpers

Weather ("do I need a jacket?"), live flight status by flight number ("where's AA395?"),
text messages, YouTube channel stats, audio transcription (`thundergate transcribe` for a
file, or just send a voice note). Small things, zero friction.

---

## 4. Memory: an agent that actually remembers

This is the reason ThunderGate exists. Your agent doesn't start from zero each morning, and
you don't repeat yourself.

### It just works

Every conversation builds memory. People, preferences, decisions, projects, promises — the
agent recalls what's relevant when it's relevant, without being asked. When you *do* want to
ask directly:

- **"What do you remember about the Henderson deal?"** — searches its long-term memory.
- **"When did we decide that?"** — it can pull up the original exchange, not a paraphrase.

### Memory you can trust (what 1.2.4 guarantees)

Nothing enters your agent's long-term memory without being **checked against what actually
happened**. A memory that can't be traced to a real conversation or a real event doesn't get
in. Your agent proposes; the verifier disposes.

### The nightly tidy-up

Each night, your agent reviews the day: what should be remembered long-term, what was routine,
what was noise. As of 1.2.4 this mostly runs itself —

- Clear keepers are filed automatically. Junk is dropped automatically.
- Only the **genuinely ambiguous** items are brought to anyone, and sensitive categories
  (things about relationships, feelings, preferences) are *never* auto-filed — they always
  get a real review.
- Expect a couple of questions a day at most, not homework.

Want to see or steer it? Ask: **"show me what's staged from last night"**, then approve or
reject items in plain language. **"Remember this permanently"** stars a memory so it's always
kept and surfaced first. **"Forget that"** / **"that's wrong, remove it"** works too — with
an audit record, like everything else.

### Promises

Your agent tracks open commitments — yours and its own. "What's still open?" gets you the
list; things you've promised people don't fall through the cracks. (`thundergate promises list`
from the command line.)

---

## 5. Your agent stays itself

Your agent's identity — its name, personality, principles, boundaries — lives in a document
you can read, and as of 1.2.4 that identity is **actively present in everything it does**,
no matter how long the session or how heavy the workload. Drift is a closed class.

- **Changes are consensual.** Your agent can propose an edit to its own identity, but edits
  are tiered: small things it can adopt, and hard-boundary changes require *your* explicit
  approval. It cannot quietly rewrite what it is.
- **Changes are reversible.** Every identity edit keeps a 30-day recoverable history. If you
  ever wonder "did something change?" — the answer is on record, and undoable.
- **Consistency is checked nightly.** What the identity documents say and what long-term
  memory says are cross-checked; drift gets flagged to you, not papered over.

---

## 6. The vault: your secrets, your key

ThunderGate holds secrets in **two strongly encrypted vaults**, each with its own job:

- **Your vault (PII)** — your identity, financial, medical, and account information. Yours.
- **The agent's vault (credentials)** — the API keys, tokens, and logins the agent works with.

### The one guarantee that matters most

**Your agent uses secrets without seeing them.** When it logs into a site, the vault hands the
browser a *handle* — the real value is substituted only at the final destination. The secret
never appears in the agent's context, in a chat log, in memory, or on screen. For your PII the
bar is even higher: the value is never visible to the agent at any point.

### Working with the vault

In conversation: "add my frequent-flyer number to the vault," "is the vault unlocked?",
"lock it," "what's stored?" (labels only — never values), or "read me back my policy number"
(a deliberate, password-confirmed, logged act — the only path by which a stored value ever
travels *to you*, and never to anyone else).

At the command line, the full kit:

```
thundergate vault status | unlock | lock | list
thundergate vault add <category> <label>        # identity | financial | medical | auth
thundergate vault receipts                      # the hash-chained access log
thundergate vault-a status | unlock | list      # the agent's credential vault
thundergate vault-a add <name> <value>          # give the agent a working credential
```

- **Change your vault password anytime** — one command re-secures every entry under the new
  password, and it's all-or-nothing by design: it either completes fully or the vault is left
  exactly as it was. Wrong-password attempts are throttled. (New in 1.2.4.)
- **Every access leaves a receipt.** `thundergate vault receipts` shows the tamper-evident
  access log — who read what, when, for what purpose. Values never appear in it.
- **Biometric approval** — on supported hardware, sensitive authorizations can ask for your
  fingerprint instead of a password.
- **Break-glass** — if the runtime is ever down and you must store something urgently, a
  password-gated, audited recovery path exists at the command line.
- **Boot unlock** — optionally, the vaults can unlock automatically at startup using your
  operating system's keychain, so an unattended agent comes up working.

---

## 7. Trust and accountability

ThunderGate's security posture in one sentence: **your agent acts on your own authority,
as itself, on the record.**

- **BYOAA — Bring Your Own Agent Architecture** *(a Loop Protocol standard ThunderGate
  implements)*. The agent is yours, carrying authority you delegated, using access you
  legitimately have. Never evasion, never impersonation of a human, never sneaking past
  anyone's rules — faithful presentation of authorized, delegated access.
- **KYA — Know Your Agent** *(a Loop Protocol standard ThunderGate implements)*. Your agent
  is identifiable and vouched for. No anonymous mystery software acting in your name.
- **Receipts everywhere.** Consequential actions — vault access, browser actions, memory
  changes, identity edits, configuration changes — write durable, queryable records. Ask
  "what did you do today?" or `thundergate status` / the action ledger for the trail.
- **The cost ledger.** "What have you cost me this week?" gets a straight answer —
  `thundergate cost` splits fresh model spend from cached reuse, so you see what a day
  actually cost and why. You can set a daily spend threshold that triggers a warning.
- **Honesty over confidence.** When your agent doesn't know, it says so. When there's a way
  to check, it checks instead of guessing. A wrong answer with a confident tone is treated
  as the worst outcome, not an acceptable one.

### What your agent can never do to itself

Some configuration is **operator-only, by construction** — the agent cannot write it, no
matter what: its safety class, kill switch, consent allowlists, protected-asset gates, and
channel credentials. An agent that could talk itself out of its own guardrails wouldn't
have guardrails. Yours can't.

---

## 8. Ambient awareness (the quiet layer)

Left running, your agent doesn't just wait for you — it maintains a quiet, configurable
awareness:

- **Heartbeat** — periodic checks on the things you've asked it to watch (inbox, calendar,
  peers, whatever's enabled), each category with its own cadence, all silenced during your
  quiet hours.
- **Posture** — it knows when you're away, asleep, or traveling, and behaves accordingly
  (trip mode, terse hours, alert hours).
- **A learning loop** — a background advisor watches how interactions go and suggests small
  behavior tunings. It can *propose*; only a handful of gentle behavior knobs are even
  eligible, and you approve or reject each suggestion. Tell your agent "good catch" or
  "don't do that again" — the feedback lands.
- **Health self-monitoring** — the runtime snapshots its own health continuously; "how are
  you feeling?" gets a real diagnostic, and `thundergate doctor` runs the full workup
  (add `--watch` for a live dashboard, `--fix` to let it repair what it safely can).

Every piece of this is opt-in/opt-out and tunable — see the next section.

---

## 9. Tuning your agent

You don't tune ThunderGate by editing files (though you can). You tune it by asking.

- **"What knobs do you have?"** — your agent lists its tunable settings: current value,
  default, range, and what each one controls.
- **"Be less chatty when I'm busy."** / **"Give yourself more time on big jobs."** — the
  agent maps plain-language requests onto the right knobs and confirms the change.

What's tunable this way (a sampler): voice on/off, your timezone, heads-down mode behavior,
heartbeat categories and cadences, quiet hours, proactive-messaging permission and intensity,
memory-recall depth, learning-loop behavior, browser pacing and window visibility, per-day
cost warnings, reply length caps, and which model the nightly review or background advisor
uses. Model choice for the agent itself is one command: `thundergate model`.

What's *not* tunable this way: anything security-critical (see section 7). Those changes are
yours alone, made deliberately, at the command line or in the configuration file.

`thundergate configure` opens a menu for settings that want a proper sit-down, and everything
hot-applies where it safely can — no restart ritual for a timezone change.

---

## 10. A fleet, if you want one

One agent is a colleague. Several are a staff. ThunderGate agents can form a **mesh**:
your agents on different machines, connected over your own private network, each knowing
who its trusted peers are.

- **"How's the fleet?"** — health of every machine and agent, in plain language.
- **Set it up by asking** — "set up the mesh" walks you through it, one step at a time,
  checking prerequisites as it goes. It only ever connects machines *you've* configured;
  it will never invent one.
- **Look vs. touch** — a peer agent can *look* at another machine freely (read-only,
  logged), but anything that *changes* a peer machine is consent-gated, and destructive
  operations require explicit confirmation. Fixes ship as proposals a human approves
  before they deploy.
- **Family mode** — via ThunderCommo, a household's agents can share appropriate context,
  so the family's agents actually know what the family knows.

---

## 11. Command-line quick reference

Everything an owner runs on the agent's machine. (Everything else in this guide is
conversation.)

| Command | What it does |
|---|---|
| `thundergate setup` | First-time interactive setup wizard |
| `thundergate migrate` | Bring an existing agent across, verified section-by-section |
| `thundergate start` / `stop` / `restart` | Run the agent (as a background service or `--foreground`) |
| `thundergate status` | Version, uptime, model, session, tokens, cost at a glance |
| `thundergate doctor [--watch] [--fix]` | Full diagnostics; live dashboard; safe self-repair |
| `thundergate update` | Pull the latest release and restart |
| `thundergate configure` | Settings menu (model, context, profile, channels) |
| `thundergate model [id]` | Show or hot-switch the agent's model |
| `thundergate tui [mode]` | The terminal cockpit: `chat`, `split`, `browser` |
| `thundergate cost [period]` | Spend report: today, week, month, all |
| `thundergate memory list` / `show <key>` | Inspect long-term memory directly |
| `thundergate promises list` / `close <id>` | Open commitments |
| `thundergate cron list` / `add` / `remove` | Scheduled tasks |
| `thundergate vault …` | Your PII vault (section 6) |
| `thundergate vault-a …` | The agent's credential vault (section 6) |
| `thundergate transcribe <audio>` | Local speech-to-text on an audio file |
| `thundergate worldstate` | The agent's current picture of its world |

---

## 12. The ThunderGate family

Each product installs on its own — take only what you need:

- **ThunderGate** — the personal agent runtime. This guide.
- **ThunderLoop** — the same proven engine, business-tuned and connected to the Loop
  Protocol for accountable business-to-business work.
- **ThunderAgent** — the phone app (iOS/Android): calls, voicemail, texts, and email —
  autonomous, or as your main agent's presence on your phone.
- **ThunderVault** — secure, end-to-end-encrypted two-way vault control from your pocket:
  push a secret in, approve an unlock, change the password, from anywhere.
- **Fidel** — the agent wallet, for when you authorize your agent to transact within
  the Loop.

---

## 13. If something's off

1. **Ask the agent.** "How are you feeling?" / "What's wrong?" — self-diagnosis is a
   real capability, not a pleasantry.
2. **`thundergate doctor`** — the full workup, with `--fix` for safe automatic repair.
3. **`thundergate status`** — is it running, what version, how long, what's it costing.
4. **Check the record.** The action ledger, vault receipts, browser audit trail, and cost
   ledger are all queryable — whatever happened, there's a receipt.

---

**Your agent. Your hardware. Your authority.** That's ThunderGate.
