All your coding agents in one hangar.
Claude Code, Codex, Pi, omp and Kimi Code in one native window and on your phone.
The agents keep running on your machines; Hangar is the control tower.
> Independent tool. Not affiliated with or endorsed by Anthropic, OpenAI, Moonshot AI or the Pi
> project. Screenshots and clips use synthetic demo data.
## Quick install
```bash
# Linux or macOS
curl -fsSL https://raw.githubusercontent.com/jeffer1312/hangar/main/bootstrap.sh | bash
```
```powershell
# Windows (PowerShell)
irm https://raw.githubusercontent.com/jeffer1312/hangar/main/bootstrap.ps1 | iex
```
Prefer an app, or want to read the files first? See [Install](#install).
## Why
One agent session is easy. Hangar is for when there are ten: some working, some waiting on a
question, some on another machine, one of them on your phone while you're out for lunch.
- **Your terminal stays your terminal.** Hangar doesn't reimplement any agent. Each session is the
original CLI, with your skills, hooks and accounts, running in tmux. Run `claude` in a terminal
and it shows up in the app; `tmux attach` and you're back in the same conversation.
- **Or no terminal at all.** Claude and Codex can run as a Hangar-managed process: permissions and
questions arrive as cards, and restarting the app never cuts a turn.
- **Nothing leaves your machine.** Self-hosted, over your LAN or your VPN. There is no Hangar cloud
in the middle.
## What you get
Many agents, one list. Claude writes the webhook while Pi translates, Kimi runs the tests and Codex calls you from the sidebar. Sessions that need you float to the top.
Sessions that talk. One agent messages another, agrees on a shared contract and reports when it's done. Pair two sessions or build a working group.
Orchestration with review. Planner, executor and an independent reviewer, each in its own session, even on different models. A gate between tasks and a final branch review before push.
What each agent spent. Tokens and estimated cost by day, provider, source and project. An estimate, not an invoice.
**Left your desk? The session comes along.** Answer the question that blocked the agent, approve a
permission, interrupt, queue the next prompt or dictate it, on your home Wi-Fi or anywhere over
Tailscale. The PWA opens in the phone's browser with nothing to install. Android and iPhone also
have a native app, outside the stores for now: in the desktop app, open Settings, Install on phone.
iPhone goes over USB, plugged into the computer running the server, with SideStore, self-signed
with your Apple ID, and shows alerts only while the app is open.
### And also
- **Native desktop app in Rust.** GPU-rendered, no browser underneath; tray icon and self-update
from the top bar. Linux, Windows and macOS.
- **A real terminal, built in.** Open the session's tmux pane under the conversation, on desktop or
phone.
- **A browser per session.** The agent opens the page it just changed, clicks, fills the form and
takes the screenshot while you watch next to the conversation.
- **Across machines.** Link your desktop, laptop and server over LAN or Tailscale: every session
in one list, and an agent on one machine messages or creates a session on another, and working
groups span machines, with one shared contract.
- **Pass the baton.** Out of quota mid-task? One button opens a new session on another account,
model or CLI, already knowing what the current one was doing. Each account's quota stays in
the top bar.
- **Git without leaving the chat.** Checkbox staging, per-file discard, history with graph and
search, cherry-pick and revert. Start a session in a fresh worktree.
- **Search every conversation**, live and closed, and resume an old one on the right account.
- **Speak and listen.** Dictation that keeps file names intact; answers read aloud. A live voice
assistant asks what an agent came up with or sends a task to another session (needs Codex and a
Codex account on the server).
- **Other models in Claude Code.** Run a Claude session on another provider and keep skills, hooks
and history.
- **Agents drive it too.** Through the `hangar` MCP server and the `hangar-send` CLI, an agent
creates sessions, lists its group, messages the others and drives its browser.
- **Share a session** with someone through a link, without exposing the rest of the machine.
- **Board and canvas** layouts, stuck-session notifications, plan progress, checkpoints for Pi and
omp, and a Portuguese/English interface.
## Install
The installer sets up the Hangar server where your agents run, installs the session shortcuts,
downloads the native app for your platform and ends with a QR code for your phone. It asks two
questions (the phone password and whether you'll use it away from home) and installs whatever is
missing: Python, Node, uv, tmux (psmux on Windows) and, if you have no agent yet, Claude Code.
### With the app (Linux and Windows)
Download the app from the [latest release](https://github.com/jeffer1312/hangar/releases/tag/native-latest)
and open it. On a machine without Hangar it offers to install the server for you in a few screens,
no terminal needed.
| Platform | File |
| --- | --- |
| Windows x64 | `Hangar-windows-x86_64.zip` (contains `Hangar.exe`) |
| Linux x86_64 | `Hangar-linux-x86_64.tar.gz`, `.deb` or `.rpm` |
| macOS Apple Silicon | `Hangar-macos-aarch64.zip` (install the server from the terminal first) |
Binaries are unsigned. On Windows, SmartScreen warns the first time: *More info → Run anyway*. On
macOS, right-click → *Open* the first time.
### From the terminal
**Linux or macOS**
```bash
curl -fsSL https://raw.githubusercontent.com/jeffer1312/hangar/main/bootstrap.sh | bash
```
**Windows (PowerShell, regular or admin)**
```powershell
irm https://raw.githubusercontent.com/jeffer1312/hangar/main/bootstrap.ps1 | iex
```
Both clone into `~/hangar` and run the installer. Other folder: `bash -s -- ~/apps/hangar` on
Linux/macOS, `$env:CP_DESTINO = 'D:\hangar'` before the command on Windows.
Prefer to read the files first?
```bash
git clone https://github.com/jeffer1312/hangar
cd hangar
./install.sh # Windows: .\install.ps1
```
Useful options: `--avancado` (pick each extra), `--agentes=codex,pi` (which agents to set up),
`--check` (only report what's missing), `--update`. On Windows: `-Avancado`, `-Agentes codex`.
Something didn't start? `hangar-doctor` says what's missing and how to fix it.
Requirements: tmux (installed for you) and at least one agent: Claude Code, Codex, Pi, omp or
Kimi Code. Setup details, Tailscale, the phone and every feature are in the
[user guide](docs/USAGE.md).
## How it works
```text
Native app (desktop) Phone app / PWA
│ │
└──── HTTPS / SSE / WebSocket ────┐
▼
hangar-server (Rust, :8765)
Claude and Codex sessions, lists, live state,
history, costs, groups, accounts, attachments,
MCP, guest logins, transcription, sharing
(guest port :8766 via Funnel, invites,
external pairs)
│
┌──────────────┬──────────────┬──────────────┬──────────────────┐
Claude Code Codex Pi / omp Kimi Code Python em loopback
JSONL + tmux app-server JSONL + ext. wire.jsonl transferência C→C,
ou sem terminal + TUI ou e sidecars e hooks runners
sem terminal
```
Chat content comes from each agent's structured transcript, never from scraping the terminal. The
tmux pane is used only for live state and input of sessions that have a terminal; headless Claude
and Codex run as managed processes with durable sidecars. The CLIs and providers you configure may
still send data according to their own policies.
O servidor é o `hangar-server` (Rust): sessões dos cinco agentes, lista, contas e cotas, anexos,
MCP, convidados, transcrição, workflows e compartilhamento (porta 8766, convites e pares externos).
Ele sobe sozinho pelo serviço do sistema; o Python que sobra em `backend/` são ferramentas (lançador
do Codex no terminal, scripts do orquestrar, chaves do push). Contratos e limites:
[contas e anexos](docs/decisoes/accounts-uploads-rust.md).
Repository map: `crates/` (Rust server), `backend/` (Python tools and `.env`), `desktop-native/` (Rust
desktop app), `frontend/` (Svelte PWA), `mobile/` (Expo app, in development), `packages/core`
(shared TypeScript), `site/` (hangar.dev.br), `skills/` (agent skills shipped with Hangar).
**API de artefatos (Rust, somente o dono):** `GET /api/sessions/{name}/artifacts` retorna
`items` com referências de artefatos Claude (`id`, `url`, `title` e `version` opcional).
A consulta é passiva e não publica conteúdo.
**Tarefas por horário (Rust, somente o dono):** `GET /api/scheduled-tasks` lista as tarefas e o
fuso do servidor; `POST` cria (o `request_id` opcional faz a repetição devolver a mesma tarefa)
e `PUT /api/scheduled-tasks/{id}` edita com revisão. A mesma tarefa
oferece `PATCH /enabled`, `POST /run` e `DELETE` para ativar/pausar, executar agora e excluir.
O app nativo e o app do celular apresentam a lista e o editor em Configurações > Tarefas agendadas.
Veja [os horários, destinos e a retomada](docs/USAGE.md#tarefas-agendadas).
## Security model
Treat Hangar like a remote shell: whoever holds the token drives your agents with your user's
permissions.
- The installer sets `CP_LAN_BIND_IP=0.0.0.0`, so your whole local network can reach the server and
the token is the only lock. Use it on networks you trust; away from home, Tailscale is the easy
path. A specific address you set yourself is kept. Started by hand, the server binds to loopback
by default, and it refuses to bind beyond loopback with the default token.
- Never expose the main port (8765) through a router port-forward or a public tunnel.
- Sharing a session uses a separate guest port (8766, served by the Rust server and published
through Tailscale Funnel) that refuses the owner's token and only reaches the shared session.
- Keep tokens, cookies and provider keys out of screenshots and issues.
## Development
```bash
# Server on loopback (reads backend/.env; binary from CP_RUST_SERVER_BIN, the install or crates/target/release)
cd backend && CP_AUTH_TOKEN="$(openssl rand -hex 24)" CP_LAN_BIND_IP=127.0.0.1 ../scripts/hangar-server-command
# Web app (PWA)
npm ci --workspace=@hangar/core --workspace=frontend
npm --prefix frontend run dev
# Checks
cd backend && uv run pytest
npm run check # svelte-check + tsc for every TypeScript package
scripts/verificar-local # what CI would run for the current commit
# Rust targets keep the previous copy of every test executable and incremental session
scripts/podar-target crates/target desktop-native/target
```
Contributor notes, architecture rules and the decisions behind them are in
[`CLAUDE.md`](CLAUDE.md) and [`docs/decisoes/`](docs/decisoes/).
## License
[MIT](LICENSE)