# How i9 handles your data

*Plain language. No legalese.*

---

## Your work stays on your machine

i9 runs virtual machines locally. It does not read your projects, and
nothing you do inside a virtual machine is uploaded anywhere.

The only network request i9 makes on its own is downloading the virtual
machine image you name, from a.i9.io or from whatever host you point it
at. That request carries the beacon described below. A run that uses an
image already on your disk makes no request at all. Commands you run
yourself (`i9 update`, `i9 grant request`, `i9 grant renew`) contact the hosts listed under "Network connections i9 makes".

There is no upload. There is no account. There is no automatic version
check — `i9 update` runs only when you invoke it. To send nothing at all,
run `i9 config set telemetry.enabled false` and use a local image.

---

## What i9 does on your machine

- **Starts a virtual machine** using your operating system's hardware
  virtualization, and streams the image while the machine runs
- **Runs the commands you give it inside that machine.** You run as
  `dev` with passwordless `sudo`, so you have root in the guest; those
  commands affect the guest, not your computer
- **Writes under `~/.i9`**: the binary, images it fetched, snapshots you
  took, traces of what ran, and — while a machine runs — a scratch file
  per machine under `~/.i9/scratch` (`scratch-<pid>-….btrfs`, plus a
  `.fork-…` copy for each fork; on Linux a `restore-<pid>-…` directory).
  It is a sparse file: `ls -l` reports 64 GiB, but it takes disk space
  only for what the guest wrote. It is removed when its machine stops; one
  left by a machine that crashed or was killed is reclaimed when a later
  machine starts
- **Records what ran in a trace** under `~/.i9/sessions`: each command's
  name and arguments, its process id and parent, its user and group id,
  its exit code and how long it took, in the guest and on your computer;
  the paths under `~/.i9` that i9 read or wrote (they include your home
  directory) and the hosts it reached. Of a command's output it keeps how
  many bytes each of stdout and stderr carried, not the output itself; of
  its environment, how many variables it was given, not their values. A
  secret's value is never in a trace. Arguments are recorded as typed, so a
  value you pass on a command line is in the trace; give secrets through
  `i9 secret`, never as an argument
- **Keeps an image page cache in `~/.i9/store`**: each `i9 run` adds the
  image pages its machine streamed to a `win-….i9io` file there, and a
  later run of the same image, in any machine, reads them from disk
  instead of fetching them again. It is a cache, so `i9 vm stop --discard`
  leaves it (the traces under `~/.i9/sessions` stay too). By default it is
  capped at the smaller of 4 GiB and a tenth of the cache's own size plus
  the free space on its disk; past the cap the least recently used files
  go first, and nothing is added while the disk is under 2% free (a floor
  clamped between 1 GiB and 8 GiB). `i9
  store ls` lists it, `i9 store prune` reclaims it (by size, by age, or
  `--all`; it refuses while a running machine holds the cache), and `i9
  uninstall` removes it
- **Writes in `/tmp` and your per-user temp directory while a machine
  runs**: i9's per-run control sockets (`/tmp/i9-*.sock`, on Linux and
  macOS regardless of `$TMPDIR`), removed when it stops, and the live-VM
  registry that counts running VMs
  (`/run/user/<uid>/i9/vms` on Linux, `$TMPDIR/i9/vms` on macOS), a lock
  file and one small record per running VM
- **Opens a host port only when you ask it to**
- **Sends your OS/arch and coarse version** on an image fetch, with no
  identifier (opt-out: `i9 config set telemetry.enabled false`)

Apart from the temporary files above, i9 writes nothing outside `~/.i9`
unless you ask it to: `i9 agent install` edits the configuration of coding
agents you select, under their own directories in your home, and reads
them back to report what is registered. To remove i9: stop any running
VM, `i9 uninstall --dry-run` to see what would be removed, then
`i9 uninstall --force`. Plain `i9 uninstall` removes the binary, `~/.i9`,
the agent wiring `i9 agent install` wrote, and the per-run state i9 leaves
in `/tmp` and under `$TMPDIR`, but refuses while saved snapshots, session
traces or the secrets store exist; `--force` deletes those too.

---

## Telemetry: what we collect

Three facts, and nothing else. The beacon carries:

- Your OS (`linux`, `macos` or `windows`)
- Your CPU architecture (`x86_64` or `aarch64`)
- A coarse version number

**No identifier.** There is no install id, no account, no hostname, no
username and no hardware fingerprint, and the beacon writes nothing to
your home directory to be read back on a later run.

i9 does keep one persistent file of its own: a signing key at
`~/.i9/producer.seed`, so that archives you create carry your own
installation's signature. It is generated locally, never sent anywhere,
and no part of it appears in the beacon. Deleting it makes i9 create a
new one.
Two restores on one machine look exactly like two restores on two
machines.

It rides the first request of a remote image fetch — the request the
restore already makes — so there is no separate connection and nothing
is sent by a run that uses a local image.

At our edge, each funnel request writes one analytics data point: the
funnel step, which published image line it concerned, the name of the
public file if one was downloaded, the three facts above, the format it
was served in, and a timestamp. Each is from a fixed list we define, not
text your machine supplies. We store no IP address, no location, no user
agent and no identifier, so a data point records a request and not a
requester. We read them only as counts per platform, version and step, and
the analytics store deletes them after its own retention window.

Each ranged read of a published image writes one more data point: the
image line and version, the operating system and CPU architecture, and
the byte offset and length read. It carries no identifier, so reads
cannot be grouped by machine or run; we read these only summed across all
users, to learn which parts of an image restores need.

With nothing identifying collected, there is no record of your machine to
disclose or delete; privacy questions go to privacy@i9.io.

We do **not** collect: session events, run outcomes, error categories,
crash reports, timing, the commands you ran in the guest, file paths, or
anything that identifies your work. The beacon does not name the image you
ran; the edge records which published image line the request was for, from
our own fixed list. A crash writes
its backtrace to your terminal, and a virtual machine fault also appends
one to a log in your system temp directory. Neither is sent anywhere.

**Disable it:** `i9 config set telemetry.enabled false` (for good) or
`DO_NOT_TRACK=1` (one invocation).

---

## Network connections i9 makes

| Connection | When | What's sent | Disable |
|---|---|---|---|
| Telemetry beacon | On the first request of a remote image fetch | OS/arch, coarse version; no identifier | `i9 config set telemetry.enabled false` |
| Image fetch | `i9 run <url>` | Range requests for the image's bytes | Pass a local file instead of a URL |
| Version check | `i9 update` | Your version number | Only runs when you invoke it |
| Free grant | `i9 grant request`, `i9 grant renew` | Nothing for a request; the grant id for a renewal, to https://i9.io/grant | Only runs when you invoke it |
| Feature request | `i9 grant request --feature <id>` (for example `nested-virt`) | The feature id, and the grant id when this machine holds a grant, to https://i9.io/grant. The issuer records the feature id, the grant id and the time, and no IP address | Only runs when you invoke it |

With the beacon off, i9 reaches the network only when you ask it to: a run
whose image is a URL, an `i9 update`, or an `i9 grant request` or `i9 grant
renew`. There is no upload path of any
kind — i9 has no way to send a snapshot, a trace or a guest filesystem
anywhere.

---

## What we keep, outside the binary

Three things reach us only because you send them:

| Store | What it holds | Kept for |
|---|---|---|
| Feedback (feedback.i9.io, Cloudflare R2) | The text you submit, its arrival time, your client's user agent, and the i9 version and agent name if sent; no IP address | 60 days, then deleted automatically |
| Mail (Google Workspace) | Messages to an i9.io address, with the sender address and attachments | Until answered and no longer needed, or as the law requires |
| Grants (the grant issuer) | The grant id it issues, its issue and renewal times and expiry, and which feature was asked for; no network address and no email (grants are free, no payment and no account; a machine already holding a live grant is refused and told to renew) | The grant's life — 7 days per request or renewal |

The privacy policy states the same, with who processes each: <https://i9.io/privacy>

---

## Where this is stated

The Terms of Service are served as text at https://i9.io/terms, and the
published documents are indexed at https://i9.io/vm/docs

This page ships inside the binary: `i9 docs DATA-HANDLING` prints it with no
network.

i9 shows no interactive first-run prompt; the beacon is the one
connection it makes unasked, and the knob above turns it off.
