heet: a fleet manager for Claude Code

The heet dashboard: requests waiting on you, live sessions on four machines, quota per account and the week ahead — Dashboard

Answer from anywhere

Permission prompts, questions and plans come to you. Whichever answer lands first wins: the terminal, the browser or your phone.

The Requests page: a permission prompt for go test with Approve and Deny, and a plan waiting for approval — Requests

Waiting on you: four requests from two sessions — Waiting on you

Approve on a phone

Every machine you own

One server, and a daemon on each machine. Agents live in tmux, so they outlast restarts and you can attach to any of them.

The Sessions list: live and finished sessions with their project, machine, account, model and tokens — Sessions

Settings, Machines: ope and kiln on Linux, mini on macOS, den on Windows, with their heet, Claude Code and git versions — Machines

The Git page: every repo on every machine with its branch, changes, worktrees and last commit — Git

Every turn, live

Tool calls, diffs and subagents as they happen, what each turn cost, and every command an agent ran.

A session: the plan it is implementing, tool calls and notes in the timeline, and its details, tokens and context on the right — Session

Session insights: context over the main thread with compactions, and tokens by tool — Insights

The Commands page: a running dev server with its CPU, memory, processes, network and file writes — Commands

Ask the fleet

The orchestrator runs heet for you. It starts agents in the right repo, checks on them, sets timers and keeps the boards.

A board for the heet project with Issues, In progress, Review and Done — Boards

Orchestrator

One pool of accounts

Log in each Claude account once. New sessions go to the one with the most headroom, and you see what everything would cost at API prices.

Analytics: tokens over time by project, tokens by kind, cache hit ratio and models — Analytics

Settings, Accounts: the pool's headroom and each account's 5-hour and 7-day quota — Accounts

The week ahead: each account's quota at its recent pace, with resets and where it would run out — Weekly quota

A computer per agent

Give an agent its own VM: the project shared in, the network behind a proxy, a screen you can watch or take over.

VM session

Hands on the keyboard

Split any page beside another, move between tabs and jump anywhere without reaching for the mouse.

Splits

A saved plan with its revisions and the sessions that implemented it — Plans

Command palette

In your pocket

The whole UI works on a phone. The iPhone app adds push with lock-screen actions, a widget and a share sheet.

A session's timeline on a phone — Session

The Requests page on a phone with Approve and Deny — Requests

Quota per account: 5-hour and 7-day windows, one at its limit, one logged out — Quota

Install · v0.41.0 · 2026-10-26

Get heet

01
A server
heet-serve keeps the state and serves the UI. Docker on any Linux host, or a package on your own computer.
02
A daemon per machine
It runs the agents. The desktop apps set it up and find the server on your tailnet.
03
Open it anywhere
In the app, a browser or on your phone, from any device on the tailnet.

Server

Linux, x86-64. heet-serve with Postgres, joining your tailnet as a device of its own.

Composeheet-serve with docker compose

mkdir heet && cd heet
curl -fsSLO https://storage.oiko.lol/plus3/heet/files/compose/compose.yaml
curl -fsSL -o .env https://storage.oiko.lol/plus3/heet/files/compose/env.example
$EDITOR .env        # POSTGRES_PASSWORD, TS_AUTHKEY, HEET_VERSION
docker compose up -d

Then open https://heet.<your tailnet>.ts.net. The tailnet needs MagicDNS and HTTPS certificates on.

pacmanArch: everything on one computer
```
sudo pacman -Sy heet-serve heet-app
systemctl --user enable --now heet-serve
```
Its own Postgres, on 127.0.0.1:7070. Set up the [heet] repository first (Linux tab). Settings → Tailscale puts it on your tailnet for your other devices.

Linux

x86-64. The app runs heet-daemon as your systemd user service and shows heet in a window.

AppImageHeet desktop appDownload ↓
Everything inside, tmux included. chmod +x and run it; it adds itself to your app menu and updates itself.

pacmanArch: the app, or just the daemon

curl -fsSL https://storage.oiko.lol/plus3/signing-key.gpg | sudo pacman-key --add -
sudo pacman-key --lsign-key plus3
printf '\n[heet]\nSigLevel = DatabaseRequired PackageOptional\nServer = https://pkg.oiko.lol/plus3/heet/heet\n' | sudo tee -a /etc/pacman.conf
sudo pacman -Sy heet-app        # or heet-daemon, then: systemctl --user enable --now heet-daemon

aptDebian and Ubuntu: the daemon

sudo install -d /etc/apt/keyrings
curl -fsSL https://storage.oiko.lol/plus3/signing-key.gpg | sudo tee /etc/apt/keyrings/plus3.asc >/dev/null
echo "deb [signed-by=/etc/apt/keyrings/plus3.asc] https://pkg.oiko.lol/plus3/heet/deb stable main" \
  | sudo tee /etc/apt/sources.list.d/heet.list
sudo apt update && sudo apt install heet-daemon
systemctl --user enable --now heet-daemon

macOS

Apple Silicon, macOS 12 or later. Agents can drive Xcode and the simulators; VM sessions run on Virtualization.framework.

AppHeet for MacDownload ↓
Signed and notarized, and it updates itself. Needs tmux (brew install tmux) and the Xcode Command Line Tools.
ScriptJust heet and heet-daemon
```
curl -fsSL https://storage.oiko.lol/plus3/heet/dl/mac/install.sh | sh
```
Installs to ~/.local/bin and loads a LaunchAgent. Run it again to upgrade.

Windows

Windows 10 1803 or later, or 11. Agents run natively in Git Bash, no WSL.

InstallerHeet SetupDownload ↓
Installs for you alone, no administrator, plus Git for Windows and Claude Code if they're missing. Not code-signed yet: SmartScreen → More info → Run anyway.

PowerShellWithout the installer

irm https://storage.oiko.lol/plus3/heet/app/app/install-windows.ps1 | iex

Every machine needs Claude Code. Machines talk over Tailscale, so heet adds no logins or certificates of its own.