# Run an Aether node — operator guide

Aether pays you to run small verification checks from your home internet
connection. Advertisers and websites need to know how their content actually
looks from real households — not from data centers. Your machine performs those
checks, and you're paid per completed job.

Two promises up front, straight from the disclosure you'll be shown before
anything runs (and which the software enforces):

> Aether only ever contacts the specific URLs a job names. It never looks at
> your own browsing, your files, or anything else on your network.

> We never share your IP address with customers. They see only the coarse
> location of your connection — country, region, and internet provider.

Everything is **deny-by-default**: the worker does nothing you haven't both
turned on in its config *and* explicitly consented to after reading the full
disclosure. This guide never asks you to skip that step.

## 1. Install (one line)

```sh
curl -fsSL https://api.runaether.run/install.sh | bash
```

The installer:

- downloads the `aether-worker` program for your platform (macOS on Apple
  Silicon, or Linux x86-64) and **verifies its published SHA-256 fingerprint
  before installing** — a mismatch aborts the install;
- puts it in `~/.aether/bin/` and writes a starter config at
  `~/.aether/worker.toml` with **every work type off**;
- does **not** enable anything or consent to anything on your behalf.

## 2. Read the disclosure and opt in

```sh
~/.aether/bin/aether-worker consent --config ~/.aether/worker.toml
```

This prints the full plain-language disclosure — what runs on your machine,
what data leaves it, what never does — and asks you separately for each work
type:

- **Network checks ("net")** — a locked-down sandbox fetches specific web
  pages. Every request's hostname and byte count is recorded and shown to you.
- **Browser render checks ("render")** — a *separate*, pinned,
  fingerprint-verified copy of Chrome or Firefox (never your own browser or
  profile) loads one specific ad tag or URL and measures how it rendered. Its
  only network path is a local gateway that blocks everything on your home
  network, enforces your deny-list and byte limits, and never inspects content
  (no TLS interception, ever).

Answer yes only to what you're comfortable with. Your answers are recorded in
`~/.aether/consent.json` with the exact version of the disclosure you read; if
the disclosure ever materially changes, you'll be asked again before any new
work of that kind runs.

Agreeing also turns the matching work type on in `~/.aether/worker.toml` for
you — nothing else to edit. The config stays your kill switch: set a work
type's `enabled = false` there and it stops (see §5); turning it back on later
doesn't require consenting again.

## 3. Run

```sh
~/.aether/bin/aether-worker run --config ~/.aether/worker.toml
```

If you enabled a work type you haven't consented to yet, the worker shows the
disclosure and asks right there; nothing runs before your yes.

Don't want to keep a terminal open? Install it as a background service — it
starts when your machine boots and restarts if it crashes:

```sh
~/.aether/bin/aether-worker install-service --config ~/.aether/worker.toml
```

No admin password needed — it runs entirely as your user (launchd on macOS,
`systemd --user` on Linux). Logs go to `~/.aether/worker.log` on macOS, or
`journalctl --user -u aether-worker` on Linux. On Linux, if the install prints
a note about "lingering", run the one command it shows so the service also
runs while you're logged out.

Remove it just as easily:

```sh
~/.aether/bin/aether-worker uninstall-service
```

That stops the service and deletes only the service entry — your config,
identity, and activity log stay put.

**Linux (Ubuntu 23.10 or newer) note:** the pinned Chrome used for render
checks needs one system setting to start:

```sh
sudo sysctl kernel.apparmor_restrict_unprivileged_userns=0
```

This *keeps Chrome's own internal sandbox ON* — Aether never disables it. The
worker detects the condition and tells you before anything runs.

## 4. See what your machine actually did

```sh
~/.aether/bin/aether-worker activity --config ~/.aether/worker.toml
```

A local log of every check that ran: what kind, which hostnames were
contacted, how many bytes, when. It's your machine's own record — the same
numbers that go into each job's signed receipt, and nothing more is collected.

## 5. Change your mind, any time

- **Pause everything:** stop the worker (Ctrl-C in the terminal, or
  `aether-worker uninstall-service` if you installed the service). Stopping
  the worker stops all work immediately.
- **Drop a work type:** set its `enabled = false` in `~/.aether/worker.toml`;
  the change applies when the worker restarts.
- **Narrow it instead:** add hosts to `allow` (net) or `deny_hosts` (render)
  in the config — your settings always override whatever a job asks for.
- **Uninstall:** run `aether-worker uninstall-service` if you installed the
  service, then delete `~/.aether/`. That's the whole footprint.

One file to treat with care: `~/.aether/worker.key` is your node's identity
and how your earnings are attributed. Back it up; never share it.

## Getting paid

During the pilot, payouts are handled manually — we track your completed jobs
(the same records you see in `activity`) and settle with you directly.
Automated payouts come later; we won't ask you for payment details to start.

## Questions

Something unclear, or something on your machine doesn't match what the
disclosure promises? Stop the worker and tell us — that gap would be a bug of
the highest order, and we want to know immediately.