# Sharing and access

Access is between two people and points one way at a time: someone can reach a machine of
yours, or you can reach a machine of theirs. This page covers how access starts, how to see
who has it, and how to end it.

## What access controls

Access decides routing. A machine only serves the people it was shared with, and your
requests only reach machines somebody shared with you. There is no path from a stranger's
machine to yours or back.

Each direction is a separate act by the person whose machine it is. Being given access does
not give access back, and asking someone for access does not offer them yours.

## Accepting an offer

When someone offers you access, they hand you a link. Redeem it:

```bash
saylek circles join --invite https://saylek.com/c/<circle-id>/<token>
```

The bare composite form works too:

```bash
saylek circles join --invite <circle-id>:<token>
```

Either form works.

**Accepting is the consent.** Once you have accepted, requests your own machine cannot serve
may run on the other person's GPU by default. Read [Privacy and
egress](/docs/privacy-and-egress) before you accept on a machine that handles sensitive work.

## Offering access to someone

```bash
saylek circles invites-mint --circle-id <circle-id>
```

Links are single-use and expire in 24 hours by default. `--uses N` (1 to 100) lets one link
admit up to N people, and `--expires` takes a duration such as `7d`, `24h`, or `1h`.

As written above it only prints the link, and delivering it is your choice. Add `--email`
and Saylek sends it for you:

```bash
saylek circles invites-mint --circle-id <circle-id> --email them@example.com
```

An emailed offer defaults to a 7-day expiry rather than 24 hours. See
[Invite flow](/docs/invite-flow) for the whole picture.

If a reusable link has spread further than you intended:

```bash
saylek circles invites-reset --circle-id <circle-id>
```

That revokes every active link you issued, so previously shared links stop working. It is
idempotent: resetting when nothing is active still succeeds. Mint a fresh link afterwards.

## Seeing who has access

```bash
saylek circles members --circle-id <circle-id>
```

The roster shows each person's display name, role, start date, and user id. It shows a
placeholder where a display name is unset, because the roster is **email-blind by design**:
people do not see each other's email addresses.

Note the difference from:

```bash
saylek circles list
```

That one is **offline and device-local**. It reports the credentials *this machine* holds,
not everything you can reach. It is honest about that limit in its own output.

## Ending someone's access

```bash
saylek circles kick --circle-id <circle-id> --user-id <user-id>
```

Find the user id with `saylek circles members`. Add `--yes` to skip the confirmation when
scripting. This is reversible: you can offer access again with a fresh link.

Removing someone plus `invites-reset` is the complete removal, because only you can mint a
way back in.

## Giving up access you were given

```bash
saylek circles leave <circle-id>
```

Note that `leave` takes the id **positionally**, unlike the commands above, which take
`--circle-id`. When in doubt, `saylek circles <command> --help` is authoritative.

It is reversible: accept a fresh offer later. It drops those models from your reach within
seconds, and nothing else you can reach is affected.

Giving up the **last** one also withdraws the egress default: with nobody sharing with you,
Saylek stops routing your requests to anyone. Two caveats worth knowing, both covered on
[Privacy and egress](/docs/privacy-and-egress): your machine caches this for a few minutes,
so the change is not instantaneous, and none of it touches a proxy upstream you configured
yourself.

For pausing or deleting your whole account instead, see
[Common commands](/docs/cli-reference).

## Next steps

- [Privacy and egress](/docs/privacy-and-egress): what the person serving you can see.
- [Invite flow](/docs/invite-flow): emailing an offer to one person.
- [Sharing your GPU](/docs/share-your-models): letting someone reach the models your machine runs.
