# Sharing your GPU

Sharing a machine is how its models become reachable by someone else. It is always an
explicit choice: nothing you do as a consumer ever turns your machine into one that serves
other people.

## What sharing commits you to

When you share a machine, it serves requests from the people you shared it with while your
GPU is idle. Sharing yours does not share theirs with you: each direction is a separate
decision by the person whose machine it is.

Two things are worth being clear about before you start:

- **Your own work takes priority on your own GPU.** A request from someone you share with
  is dropped when your own work arrives, at the next step of the work rather than instantly.
- **You will see what you serve.** Serving a request means your machine handles that
  person's prompt in the clear, because that is how it computes the answer. The other side
  of this is documented for consumers in [Privacy and
  egress](/docs/privacy-and-egress); sharing puts you on the receiving end of that trust.

The full version of what sharing a machine commits you to, including what serving does *not*
expose and who is answerable for what, is the [Acceptable Use Policy](/aup). Read it before
you run the wizard below rather than after: running it is the act that agrees to it.

## Requirements

| | |
|---|---|
| Hardware | A GPU the daemon can serve from. NVIDIA via `cuda`, Apple Silicon via `metal`. |
| Binary | A build with an inference backend compiled in. Released binaries have one. |
| An account | You must be signed in with an active Saylek account. |

A from-source build with no `--features` flag compiles but cannot serve: the first call
returns HTTP 503 `no inference backend compiled in`. Build with `cpu`, `cuda`, or `metal`.

## Start sharing

Get a model serving first, if you have not already:

```bash
saylek gpu wizard
```

Then turn sharing on:

```bash
saylek host wizard
```

The wizard is what actually turns sharing on: it sets `[host].enabled`, resolves and writes
the models you will advertise, mints the machine credential and installs the background
service. `saylek gpu wizard` above gets a model serving locally, which is a different thing
and does not start sharing. Bare `saylek host` is the serve verb for a machine that is
already set up; on one that is not, it refuses and points you back here.

Afterwards, `saylek host` runs the up-path in the foreground if you want to watch it.

Confirm what your machine is offering:

```bash
saylek models     # what this machine can serve right now
saylek status     # health, and whether you are connected
```

## Stopping: three different scopes

These are easy to confuse, and one of them is much larger than people expect.

| You want to | Command | What keeps working |
|---|---|---|
| Stop **serving other people**, keep using Saylek yourself | `saylek host pause` | Your own inference, and who you share with |
| Stop the **daemon** entirely | `saylek stop` | Nothing. `saylek call` will not answer until `saylek start` |
| Step away from Saylek but keep your account | `saylek settings account deactivate` | Reversible with `activate` |

`saylek host pause` is the small, targeted one, and it is what the "Pause contributing"
control on your home page does.

There is no bare `saylek pause`. "Pause" means two different things at two different scopes,
so the CLI does not guess which one you meant: it answers with both commands and lets you
pick. Use `saylek host pause` when you mean serving other people, and `saylek stop` when you
mean the daemon.

## Checking what your machine served

```bash
saylek statement <YYYY-MM>
```

A record of where each request ran. Nothing is owed in either direction.

## Next steps

- [Sharing and access](/docs/sharing-and-access): who your machine will serve.
- [Troubleshooting](/docs/troubleshooting): when your machine shows as offline.
- [CLI reference](/docs/cli-reference): the full everyday command table.