Hangar.AI

Run Claude Code, Codex, Gemini CLI and OpenCode side by side in one window,
sharing a task board and a memory over MCP, and follow and steer them from your phone.

Website · Browser demo · Hangar Mobile · Download · Changelog · Discord

_{Screenshots of a real session: Claude Code agents at work on checkout-v2, a sample repository.}

Hangar.AI is an open-source desktop app for Windows, macOS and Linux, built with Tauri 2 and React. It runs the coding agents you already use, each in a real terminal, and gives them a shared place to coordinate.

With Hangar Mobile, you follow and steer them from your phone while Hangar keeps running on your PC: see what waits for you in every project, answer an agent, allow or deny a permission, and reply to Claude's questions with a tap in a real chat. Hangar serves it itself, through your own Tailscale network: no app store, no account and no server of ours. Set it up in about a minute.

_{Hangar Mobile on its sample projects.}

Why Hangar

Running several coding agents at once usually means a pile of terminal windows. You lose track of which one is waiting for you, two of them edit the same file, and none of them knows what the others are doing.

Hangar keeps them in one window, and on your phone:

• One window, many agents. Up to 16 terminals per workspace. Each pane shows whether its agent is working, waiting for your answer, or done.
• On your phone (new in 1.1). Hangar Mobile lists what waits for you in every project. Answer an agent, allow a permission or reply to Claude's questions from the phone, while the agents keep working on your PC.
• A shared board. Agents read and write a kanban board per workspace over MCP. Claims are atomic, so two agents cannot take the same task.
• A shared memory. Facts one agent records are there for the next session, in any project.
• Orchestration (new in 1.0). One agent plans. Workers do the work in separate git worktrees, and each delivery is reviewed, and run through your check command if you set one, before it is merged locally.

Hangar launches the agent CLIs installed on your machine, with your accounts and your settings. It is not a model provider, and it has no online service of its own.

Contents

• Features
• Install
• Getting started
• Hangar Mobile
• How agents use Hangar's MCP server
• Privacy
• Build from source
• Repository layout
• Contributing
• License

Features

On your phone: Hangar Mobile

Follow and steer your projects from your phone while Hangar keeps running on your PC (new in 1.1, with a real chat since 1.2):

• For you lists what waits for you in every project: an agent asking for a permission, a question from an orchestrator, a delivery ready to land.
• A real chat. A Claude Code pane, and the project manager, open as a conversation: your messages, Claude's answers with their formatting, and one line per action that opens its detail. Codex, Gemini CLI and shells keep the terminal view.
• Claude's questions as buttons, several choices when it allows them, and "Other" with a text field. Your answer reaches the session on the PC as if you had typed it there.
• Permissions show the tool and what it will do (the command, the file), with Allow and Deny.
• Files and notifications. Agents share images and files with you through phone_share, and notifications reach the phone even with the app closed.
• Since your last visit shows what happened while you were away.

It reaches your PC through Tailscale, from your own devices only. See Hangar Mobile to set it up.

Orchestrator mode

Pin a Claude Code pane as a workspace's orchestrator. It plans the work on the board and starts workers to carry it out. You follow everything from one window.

How it works

1. Plan. The orchestrator breaks the goal into board tasks. Each task lists its dependencies and the files it owns.

2. Start workers. worker_spawn gives a task to a new Claude Code pane (Sonnet by default). The worker runs in its own git worktree, on a new branch from the target branch, with a block of 20 ports for its dev servers and tests. Hangar enforces the limits, whatever the prompt says:

   • it refuses a task whose files overlap a task already in progress;
   • it runs 3 workers at once by default;
   • it allows 2 attempts per task by default, then hands the task back to you.

3. Deliver. A worker hands in its branch with delivery_submit, and the branch joins a merge queue. Each delivery goes through four steps:

   • the branch is merged in a temporary worktree;
   • the workspace's check command (pnpm test, cargo test…) runs there, if you set one;
   • a separate reviewer agent reads the change with a fresh context and read-only tools;
   • if all of that passes, the branch lands on the target branch by fast-forward.

   If a step fails, the worker receives what failed and fixes it. Hangar never pushes, and a landing that would overwrite your uncommitted changes is held back.

4. Wake on events. The orchestrator does not poll. When it is between turns, Hangar sends it one batched message: a worker commented, is waiting, or exited; a delivery landed or failed.

5. Needs you. One list, across workspaces, shows what waits for you:

   • agents asking for a permission or an answer;
   • questions the orchestrator handed back to you;
   • deliveries ready to merge, when automatic merging is off.

You set the following per workspace: the models of the orchestrator, workers and reviewer (Opus, Sonnet and Sonnet by default), the limits, the check command, the target branch, automatic merging (on by default) and the permission mode. Orchestration needs a git repository and Claude Code.

Needs you: what waits for you, across workspaces	Orchestration settings of a workspace

Project manager

One agent to talk to instead of every project's agents (new in 1.0.3). Open it from the top of the sidebar or the command palette: Hangar creates an HQ workspace with its own folder and one Claude Code agent (Opus by default) that follows every workspace, with or without an orchestrator.

• Ask it where your projects stand: agents, boards, what waits for you, deliveries ready to land, each plan's status.
• Ask it to pass an instruction on. It is queued for that project's orchestrator, and a sleeping workspace wakes up.
• It speaks up only for what waits for you: an agent waiting for an answer or a permission, a task marked needs-you, a delivery ready to land, a board whose tasks are all done.

It keeps a tracker of what you want from each project, handed back after every compaction. It never writes code and never acts on its own. On your phone, Hangar Mobile opens it as a chat.

An interface built like an IDE

• Navigator on the left: workspaces and folders, and each workspace's agents and their state at a glance.
• Inspector on the right: the focused pane's session, context use and cost, its board task, its queued prompts and the files it touched.
• Command palette (Ctrl/Cmd+Shift+P). Every command, pane and workspace is behind one search field.
• 33 themes. Graphite is the default; the others are ported from popular VS Code palettes. Each theme restyles the whole window, not only the terminals.
• Keyboard and language. Every shortcut can be rebound, and F6 moves between regions. The interface is in English or French.

Agents and terminals

• Agents and shells. Each pane runs Claude Code, Codex, Gemini CLI, OpenCode or a plain shell: PowerShell, cmd, Git Bash, WSL, zsh, bash, fish, Nushell…
• Session resume. Claude Code and Codex panes reopen on the conversation they were in.
• Claude Code bridge. A small mod reports turns, permission prompts, context fill and plan usage, so pane states are exact rather than guessed. When an agent edits a file another pane just changed, it is told who changed it and asked to re-read it.
• Broadcast. Send one instruction to every pane at once. Claude Code panes can also hold it until their agent is free.
• Pane tools. Zoom a pane to the full grid, search its scrollback, drop a file on it to paste its path, or run a saved command in it.

Workspaces

• Saved workspaces. A workspace is a project folder and its layout, and reopening it brings every agent back. Workspaces can be grouped in folders, or moved to a window of their own.
• Sleep. A workspace idle for 10 minutes is put to sleep to free memory. When you open it again, its agents resume their sessions. You can change the delay or turn this off.
• MCP servers per workspace. Choose which MCP servers a workspace's Claude Code panes start, instead of starting every configured server in every pane.
• Git worktrees and diffs. Create, lock and remove worktrees, open one in a pane or in its own workspace, and see what an agent changed in its folder.

Board, memory and statistics

• Task board. Priorities, dependencies, labels, assignees and comments. It opens as a full view or as a panel beside the terminals. Stored in .hangar/board.json in the project.
• Global memory. Agents search, write and update facts across projects. You can browse and edit them in the Memory view.
• Usage statistics. Tokens, active time and the equivalent cost at API prices, per project, agent and model. They are read from the transcripts Claude Code and Codex keep on disk. On a Claude or ChatGPT subscription, the cost figure is an equivalent, not a bill.

Also

• 3D preview. Agents show you a model (glTF/GLB, OBJ, STL, PLY, FBX, USDZ) in a panel, and render snapshots to check their own work.
• Dictation. Hold a key, speak, and the text is typed into the focused pane. It runs locally with whisper.cpp, on a model downloaded once. Groq is an optional alternative, with its key kept in the system keychain.
• Discord Rich Presence, off unless you turn it on.

Install

Download the file for your system from the latest release, under Assets. You only download once: after that, the app offers each new version and installs it in one click.

System	File	Notes
Windows (x64)	Hangar.AI_<version>_x64-setup.exe	Installs for your user only, without administrator rights. Needs WebView2, which ships with Windows 11; on Windows 10 the installer adds it if it is missing.
macOS (Apple Silicon and Intel)	Hangar.AI_<version>_universal.dmg	One universal build for both, macOS 10.15 or later.
Linux (x86_64)	.AppImage, .deb or .rpm	The AppImage runs without installing (chmod +x it first) on distributions with glibc 2.35 or later (2022 on). The .deb and .rpm need WebKitGTK 4.1, which apt and dnf install with them: libwebkit2gtk-4.1-0 on Debian and Ubuntu, webkit2gtk4.1 on Fedora.

Note

Windows: SmartScreen. The installer is not code-signed, so on first run SmartScreen shows "Windows protected your PC". Click More info, then Run anyway.

macOS: Gatekeeper. The macOS build is signed and notarised, so it opens after macOS's usual first-launch confirmation. If a release's notes ever say the macOS build is unsigned (or you built it yourself), macOS blocks the first launch: right-click the app and choose Open. On macOS 15 and later, go to System Settings → Privacy & Security and click Open Anyway.

You also need at least one agent CLI installed and signed in: Claude Code, Codex, Gemini CLI or OpenCode. Hangar launches them; it does not install them.

Getting started

1. Create a workspace with Ctrl/Cmd+Shift+N. Pick a project folder and a layout, then click a cell to choose its agent. Agents that are not installed are marked as such.
2. Connect the agents to Hangar. Open the MCP panel (Ctrl/Cmd+Alt+M; Alt is Option on a Mac) and click Configure. The panel can also write a short playbook into the project's AGENTS.md and CLAUDE.md, telling agents to claim tasks before they start. Restart the agents so they load the server.
3. Give them work. Add tasks on the board (Ctrl/Cmd+Alt+B), or ask an agent to split a goal into tasks. Other agents pick tasks up with board_next_task.
4. Try orchestration. In a git repository, run New orchestrator from the command palette (Ctrl/Cmd+Shift+P), or pin an existing Claude Code pane from its … menu. Then describe the goal to it. Orchestration… in the same menu opens the workspace's settings: models, limits, check command and automatic merging.

The command palette lists every command. Shortcuts can be changed in Settings → Shortcuts, and the defaults use Ctrl on Windows and Linux and Cmd on macOS.

Hangar Mobile

Hangar Mobile follows and steers your projects from your phone, while Hangar keeps running on your PC. For you lists what waits for you in every project: an agent asking for a permission, a question from an orchestrator, a delivery ready to land. You can read any pane's screen as it updates, answer an agent, allow or deny a permission, press Esc or Enter, and attach a photo or a file. You can also talk to the project manager, open the images and files agents share with you, and see what happened since your last visit. Notifications reach the phone even with the app closed. Merging a delivery is still done on the PC.

A Claude Code pane, and the project manager, open as a conversation rather than a copy of the terminal: your messages, Claude's answers, one line per action. When Claude asks you something, each question shows with its options as large buttons, and a Terminal button still shows any pane's raw screen. Codex, Gemini CLI and shells keep the terminal view.

It is a web app that Hangar itself serves, and that you add to the phone's Home Screen. There is no app store, no account and no server of ours in between.

Set it up (once, about a minute):

1. Install Tailscale on the PC and on the phone, and sign in to the same account on both. It is a free app that links your own devices through a private network, wherever they are.
2. Turn Hangar Mobile on in Hangar, under Settings → Mobile.
3. Click "Turn on HTTPS access" in the same section. Tailscale then gives Hangar Mobile an address like https://your-pc.your-tailnet.ts.net. The first time, Tailscale may ask you to allow HTTPS on your network: open the page Hangar shows, then click again.
4. Click "Show the code" and scan the QR code with the phone's camera. It opens Hangar Mobile and pairs the phone. You can also type the 6-digit code, which works once and for five minutes.
5. Add it to the Home Screen. On an iPhone, in Safari, tap Share, then Add to Home Screen. On Android, in Chrome, open the menu and choose Add to Home screen (or Install app). Open Hangar from there and tap Turn on notifications.

Note

On an iPhone, notifications need iOS 16.4 or later, and they only reach the app opened from the Home Screen, not a Safari tab.

Security:

• Hangar Mobile listens on 127.0.0.1 only, on a port of its own, apart from the agents' API: nothing is opened on your local network or on the Internet.
• Tailscale Serve is the only way in, over HTTPS, and only from devices on your own Tailscale network.
• Each phone pairs with a one-time code. Settings → Mobile lists the paired phones, and revoking one cuts it off and stops its notifications.

Your PC has to stay on, with Hangar open, for the phone to reach it. For a few days away, Settings → Mobile has two options: keep the PC from going to sleep while Hangar Mobile is on, and start Hangar when you log in, with your workspaces and Hangar Mobile.

How agents use Hangar's MCP server

The MCP server is the app's own binary, started as hangar-ai --mcp over stdio. Each call goes to the running app through a local HTTP API on 127.0.0.1. The port and the token change at each launch and are never written into agent configs. Every board change goes through a single lock, so claims stay atomic across panes.

The MCP panel registers the server in each tool's own format:

Tool	Config file
Claude Code	.mcp.json (project)
Codex	~/.codex/config.toml
Gemini CLI	~/.gemini/settings.json
Cursor	.cursor/mcp.json (project)
VS Code	.vscode/mcp.json (project)

Hangar merges its entry into the existing configuration rather than overwriting it, and keeps a backup the first time it writes a file. OpenCode is not in the panel yet: add hangar-ai --mcp to its MCP servers by hand.

Tools	What agents do with them
board_list_tasks, board_next_task, board_claim_task, board_create_task, board_update_task, board_comment_task, board_delete_task	Read the board, take the highest-priority free task whose dependencies are done, claim it (this fails if another agent holds it), split work into new tasks, move tasks between columns, and leave notes for each other.
memory_search, memory_read, memory_write, memory_update, memory_list, memory_delete	Look up what earlier sessions learned before starting, and record decisions, pitfalls and conventions. Writing an existing title replaces that entry.
workspace_list, workspace_window, pane_list, pane_create, pane_send, pane_read, pane_restart, pane_close, pane_focus	See the other panes and their state, open a pane with another agent (in a worktree, for instance), type into a pane or queue a prompt until it is idle, read its output, and show a pane to you.
worker_spawn, worker_list, worker_stop, delivery_submit, delivery_status	Orchestration. The orchestrator starts, lists and stops workers. A worker hands in its branch for check, review and merge.
model_show, model_snapshot, model_close	Open a 3D model in the preview panel, render it to an image to check it, and close it.
phone_share	Send you a file on your phone through Hangar Mobile: a screenshot, a render, a report you asked to see.
project_list, project_status, project_send	The project manager only: list every project, read where one stands, and queue an instruction for its orchestrator.

You can test the server by hand from a build:

echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | ./src-tauri/target/debug/hangar-ai --mcp

Privacy

Hangar has no account, no telemetry and no backend. Your workspaces, the board, the memory and the statistics stay on your machine:

• each workspace's board is in .hangar/board.json in the project. Hangar keeps it out of git status through .git/info/exclude, unless you commit it yourself;
• the app state and the memory are in the app's data folder;
• the statistics are computed from the transcripts the agents already keep locally, and are never sent anywhere;
• the MCP API listens on 127.0.0.1 only, behind a token that changes at each launch;
• Hangar Mobile, off until you turn it on, listens on 127.0.0.1 too, and only your own devices reach it, through Tailscale.

Hangar itself only goes online in these cases:

• Updates. It checks the GitHub release feed for a new version.
• Dictation. It downloads the speech model from Hugging Face once, when you choose it. It sends audio to Groq only if you choose Groq as the engine, and the transcript only if you turn on the optional cleanup pass, which also runs on Groq.
• Discord. Rich Presence talks to your local Discord client, and only if you turn it on.
• Hangar Mobile notifications. Once you turn them on on a phone, the PC sends them through that phone's push service (Apple's, Google's or Mozilla's), encrypted for that phone alone, so the push service cannot read them.

The agents you run talk to their own providers under their own settings. Hangar does not change that.

Build from source

You need:

• Node.js 22, as in CI (Vite 7 needs at least 20.19), and pnpm 10;
• Rust stable;
• cmake and LLVM/clang: dictation compiles whisper.cpp from source and generates its bindings with libclang;
• the Tauri prerequisites for your system:

  • Windows: the MSVC build tools and WebView2, plus cmake and LLVM (winget install Kitware.CMake LLVM.LLVM);

  • macOS: the Xcode command line tools (xcode-select --install, which includes clang) and brew install cmake;

  • Linux: the WebKitGTK, ALSA and libclang headers, as installed by CI on Ubuntu 22.04:

    sudo apt install build-essential cmake libwebkit2gtk-4.1-dev libayatana-appindicator3-dev \
      librsvg2-dev libxdo-dev libssl-dev libasound2-dev libclang-dev patchelf

Then:

pnpm install
pnpm tauri dev      # run the app with hot reload
pnpm tauri build    # build the installers for this platform, Hangar Mobile included
pnpm demo:dev       # the browser demo, with canned agents, on http://localhost:4300
pnpm mobile:dev     # Hangar Mobile against a fake PC, on http://localhost:4310
pnpm mobile:build   # Hangar Mobile into dist-mobile/, which a dev build serves to the phone

Warning

If Hangar is already installed on your machine, a plain pnpm tauri dev shares its data and its MCP endpoint. Your installed agents would then talk to the dev build. See CONTRIBUTING.md to run the two side by side.

Repository layout

src/                 React frontend (components, lib, styles, i18n)
src/mobile/          Hangar Mobile, the phone app, built into dist-mobile/ and embedded in the binary
src-tauri/src/       Rust backend: PTYs, board, memory, MCP server, git, deliveries, stats, dictation
src-tauri/claude-mod/hangar-bridge/
                     the Claude Code mod that reports session state to Hangar
src-tauri/installer/ NSIS installer script and artwork
demo/                the browser demo: src/ compiled unchanged against a fake backend
site/                the website at hangar.simnjs.fr
scripts/             logo, installer art, demo model and demo bundling scripts
.github/workflows/   CI (checks on pushes to main and on pull requests) and Release (builds and publishes on a tag)

Contributing

Questions, setups and ideas are welcome on the Hangar.AI Discord. Bug reports and pull requests go through GitHub. Start with CONTRIBUTING.md. It covers the setup, the checks CI runs and the commit style. Please follow the code of conduct. To report a security issue, see SECURITY.md and do not open a public issue.

License

MIT © simnJS