> ## Documentation Index
> Fetch the complete documentation index at: https://docs.boxd.sh/llms.txt
> Use this file to discover all available pages before exploring further.

# VM sharing

> Open a machine to your whole org with one command, with a clean credential handoff every time.

Sharing makes one of your machines reachable by every member of your organization. It's a single command, it's owner-controlled, and it's reversible.

```bash theme={"theme":"github-dark"}
boxd machine share staging         # every member of the org can now connect
boxd machine unshare staging       # back to private, yours alone again
```

Once shared, any member runs `boxd connect staging` and lands on the same machine. Unsharing only changes **who can reach it**, never who's billed.

<Note>
  **Sharing controls team access, and the web URL is a separate thing.** The machine's `https://name.boxd.sh` URL is already public to the internet. Sharing decides which **teammates** can get a shell on the machine.
</Note>

## The credential handoff

A machine you've been working on holds your personal agent logins on disk. Claude Code, Codex, and OpenCode keep their tokens in your home directory, and the moment a machine becomes reachable by the rest of your team, those tokens should not be sitting there for anyone with a shell to read.

boxd enforces this for you. **Sharing a machine wipes the in-VM agent credentials the moment it goes shared**:

```text theme={"theme":"github-dark"}
~/.claude/.credentials.json          # Claude Code
~/.codex/auth.json                   # Codex
~/.local/share/opencode/auth.json    # OpenCode
```

While the machine stays shared, boxd stops restoring these files and keeps them out of credential sync, so a login made on a shared machine stays on that machine and reaches none of your other personal machines. The machine's GitHub access also switches from your personal token to the **organization's GitHub App** token, so repo access on a shared machine belongs to the org rather than to you.

The guarantee is that **no member's personal login is ever left readable on a machine the rest of the team can reach**. Sharing is a clean handoff every time.

### Unsharing brings your logins back

Run `boxd machine unshare` and the machine is private to you again. Your agent logins come back too:

* **Claude Code re-authenticates automatically.** boxd restores your Claude login the next time you start a session on the machine.
* **Codex and OpenCode** need a one-time `codex` / `opencode` login on the machine. After that they persist normally, because a private machine is never wiped.

<Warning>
  **Don't share a machine while an agent is working inside it.** Sharing wipes credentials live, so a Claude Code, Codex, or OpenCode session running in that machine is logged out mid-task. If you need to share a machine an agent is using, make sharing the last step of the run, and expect to log in again afterward.
</Warning>

## Fork a shared machine for private work

Forking a shared machine gives you a **private fork by default**. The org keeps paying, the copy is yours alone, and your agent logins work in it right away:

```bash theme={"theme":"github-dark"}
boxd machine fork staging            # private fork: org-billed, yours alone, logins restored
boxd machine fork staging --shared   # keep the fork shared with the whole org instead
```

A private fork is reachable only by you, so nothing gets wiped. Claude Code restores automatically, and a one-time Codex or OpenCode login sticks. This is the clean way to take a shared golden machine and do focused, authenticated work on a copy without touching the shared original. Pass `--shared` when you want the fork to stay open to the org. Forking a personal machine is unchanged, and the fork stays personal.

## At a glance

| You run                                  | Reachable by | Billed to | In-VM agent logins                                   |
| ---------------------------------------- | ------------ | --------- | ---------------------------------------------------- |
| `boxd machine share <vm>`                | Whole org    | Org       | Wiped on share, GitHub switches to the org App token |
| `boxd machine unshare <vm>`              | You only     | Org       | Claude auto-restores, Codex/OpenCode re-login once   |
| `boxd machine fork <shared-vm>`          | You only     | Org       | Restored (private fork)                              |
| `boxd machine fork <shared-vm> --shared` | Whole org    | Org       | Wiped (stays shared)                                 |

See the [CLI reference](/cli/commands#organizations) for every flag, and [Authentication](/cli/authentication#org-context) for the billing and context model.