All your coding agents.
One native window.

Q: What is Halterio?

Halterio is a native desktop app, written in Rust, for running and supervising coding agents. It starts threads on the agent CLIs you already have installed, gives each one its own checkout, and shows the transcript, diff, terminals and pull request in one window.

Q: Do I need an account?

No. Halterio is local-first. There is no sign-up and no required network service; sessions stay on your machine. The optional multi-device sync runs on an edge you host yourself.

Run them side by side, each thread with its own checkout, transcript, diff, terminal and pull request.

Download See how it works

Written in Rust, local-first, no account. Installers for macOS, Windows and Linux are coming soon.

Claude Code
Codex
Cursor
Devin
Grok
Hermes
Pi
opencode
Antigravity

Fix auth token refresh

Users get signed out after an hour of idling. Find out why.

The access token lives for an hour, and it only refreshes after a request fails with a 401.

Refresh the auth token before it expires instead of on the first 401. Keep the 30-day window.

Done. refreshIfExpiring() now runs on an interval derived from the token’s exp, and the 401 path is the fallback rather than the trigger.

Ran 3 commands, edited 2 files

The tests pass. Want me to open a pull request against main?

Do anything…claude-opus-5-5↑

Local checkoutfieldnotes/fix-auth-token-refresh39%

A live replica: statuses, diffs and pull requests move the way they do in the app.

One thread, one checkout, everything in reach.

Start a thread on any installed agent CLI, pick the model and effort, and watch it work. Each thread lives in a fresh git worktree or a folder you choose, with the diff, files, terminals and pull request beside the transcript.

The Halterio window: the sessions sidebar on the left, a transcript in the middle where an agent describes the design it just wrote, and the Design side pane on the right showing the rendered page with tweak sliders. — **Halterio on macOS.** A Claude Code thread, the transcript, and the Design pane rendering the HTML the agent wrote.

A worktree per thread

Ten agents, ten branches, no collisions. Or run in a folder directly when you want to. Worktrees are listed, cleaned up and reused from Settings.
Answer, redirect, stop

Send a follow-up while the agent works, interrupt it, or answer its questions and permission prompts inline. The sidebar tells you which threads are waiting on you.
No web view in the way

gpui rendering, a virtualized transcript with streaming markdown and syntax highlighting, frosted surfaces on macOS and Windows. Hundreds of threads stay smooth.

Diff, files, terminal, pull request. And three surfaces you won’t find elsewhere.

Every thread opens surfaces beside its transcript. Some are what you’d expect from a coding tool. Three of them let the agent see what you see.

Pull requests, in scope

Open, closed and merged pull requests for the selected project or for every project, with checks, review threads and the diff. A PR opened from a thread stays attached to it.

Badge in the sidebar counts open PRs linked to your threads
Code review lists threads with uncommitted changes or an open PR
Backed by the gh CLI you already have

The pull request board listing pull requests for a project, with one open in the side pane showing its description, checks and changed files.

Design

Agents write clickable HTML designs under designs/ in the checkout. The pane renders them at Fit, desktop, tablet and phone widths, reloads live as files change, and lets you comment on elements or edit text in place.

Page view and an infinite project canvas of every design
@tweak sliders for CSS variables, written back to the file
Export PNG or PDF, or hand the design to an implementation thread

The Design side pane rendering an agent-written landing page design at the desktop viewport preset, with the design picker and viewport presets in the toolbar.

Simulators

Your iOS Simulators and Android Emulators stream live into the side pane. Click, drag, scroll and type on them, and let agents open and screenshot them while they work on a mobile app.

Three-step setup: device hub, platform checks, agent access
Agents get simulator_list, simulator_open, simulator_screenshot and simulator_close
Powered by Expo Device Hub, installed only when you turn it on

The Simulators side pane streaming a live iPhone 16 Simulator, with its home, rotate and screenshot controls, beside a new session in Halterio.

Point at an element. Say what to change.

A design in Halterio is an HTML file the agent wrote, living in your repo. That means agents edit it with the tools they already have, it versions with the code, and implementing it is a matter of handing over a path.

Comment mode

Pick an element on the page and type what you want different. The comment lands on the composer with the element’s selector, like a diff comment, ready to send.

Tweak sliders

A CSS variable with an @tweak comment gets a slider in the pane. Drag it, the page updates live; release it, the value is written back into the file.

The tweaks strip in the Design pane: sliders for gap, pad, radius-card, radius-bubble, radius-sheet and frame-gap, each with its current pixel value.

Project canvas

Every design of the project, at every viewport, side by side on an infinite board. Its layout is designs/canvas.json in the repo, so it’s shared by every thread of the project.

From a sentence to a file

Type /design-canvas onboarding flow and the agent reads your project’s designs/design-system.md, writes the page, and opens it in the pane. Agents can also look for themselves: design_open, design_screenshot, design_console and design_selection are tools every thread gets.

:root {
  --radius: 12px;      /* @tweak 0 32 1 */
  --gap: 24px;         /* @tweak 0 64 4 */
  --accent: #6d5efc;   /* @tweak color */
}

designs/onboarding.html

One agent can run the others.

Every thread gets the Halterio MCP server. A Claude Code lead can fan out Codex and Devin children, steer them while they run, wait for a turn to settle and read the result. It works across every harness because it lives in the engine, not in any one CLI.

› create_chats [
    { harness: "codex",  title: "Rate limiter for /v2" },
    { harness: "devin",  title: "Retry idempotent webhooks" },
    { harness: "pi",     title: "Audit contrast on light theme" }
  ]
✓ 3 chats created: a1f2…  7c90…  e4d1…

› wait_for_turn { chat: "a1f2", timeoutSeconds: 600 }
⋯ status: awaitingInput
  "Keep the 30-day refresh window?"

› respond_to_input { chat: "a1f2", answers: ["yes"] }
› send_message { chat: "7c90", mode: "auto",
    message: "Also cover the 5xx path." }

› wait_for_turn { chat: "a1f2" }
✓ completed, +140 −31, feat/rate-limit

A Claude Code lead thread, calling the Halterio MCP server

Tools every thread gets

create_chats: Start up to 32 threads at once, on any harness, any project, any connected device.
send_message: Steer a running child through its live mailbox, without interrupting its tools.
wait_for_turn: Block until a thread settles, needs input, errors or times out. Stale is never reported as done.
read_chat: Read a child’s transcript, status and last turn outcome.
respond_to_input: Answer a child’s question or permission prompt.
screenshot: Look at the display, then computer_action once. Only while Computer Use is on.
design_open: Open a design in the user’s pane and get a screenshot of it back.
simulator_open: Boot a simulator into the side pane and screenshot it.

$ halterio                  # the desktop app
$ halterio headless         # engine only, IPC on 127.0.0.1:28654
$ halterio daemon install   # launchd / systemd --user unit
$ halterio status           # engine and profile status
$ halterio mcp              # the tool server every thread gets
$ HALTERIO_HARNESS=mock halterio   # a scripted agent, no CLI needed

zsh

The same engine runs in the app or on a server.

The desktop app is a viewport over a local engine. Run that engine alone on a build box or a VPS and it keeps running agents, hosting terminals and computing diffs when nobody is looking.

Local-first

No sign-up. Data lives in ~/.halterio. The engine’s port is loopback-only and every connection carries a token minted at start.
Agent accounts

Switch Claude Code and Codex logins from Settings and watch plan usage meters fill up, per provider, before a run hits a limit.
Status you can trust

Working, needs input, done and errored come from the harness itself and from programs in your terminals. A stale signal is never shown as finished.
Appshots & voice

A global shortcut captures any app window into the composer. Voice input runs on-device on macOS with the bundled Parakeet model.

Thirty built-in variants. Or import yours from VS Code.

Every theme is a fully resolved palette, down to the terminal’s ANSI colors. Pick an accent override, choose frosted or opaque surfaces, or link a VS Code theme file and reload it as you edit.

Halterio Dark
Halterio Light
Dark+
Light+
Catppuccin Mocha
Catppuccin Latte
Tokyo Night
Tokyo Night Light
Dracula
GitHub Light
GitHub Dark
Ayu Light
Ayu Dark
Ayu Mirage
Gruvbox Light
Gruvbox Dark
Rosé Pine Dawn
Rosé Pine Moon
Nord
One Dark Pro
Atom One Dark
Night Owl
Night Owl Light
Winter is Coming Dark Blue
Winter is Coming Light
Palenight
SynthWave '84
Shades of Purple
Cobalt2
Andromeda

Questions, answered plainly.

What is Halterio?

A native desktop app, written in Rust, for running and supervising coding agents. It starts threads on the agent CLIs you already have installed, gives each one its own checkout, and shows the transcript, diff, terminals and pull request in one window.

Which coding agents does it support?

Claude Code, Codex, Cursor, Devin, Grok, Hermes, Pi, opencode and Antigravity. Each runs through its own CLI, with model and effort pickers, steering mid-run, and inline answers to questions and permission prompts. You need at least one of them installed and signed in.

Do I need an account?

No. Halterio is local-first: no sign-up and no required network service. Sessions stay on your machine. The optional multi-device sync runs on a Cloudflare edge you host yourself.

Where does my data live?

In ~/.halterio on macOS and Linux, or %LOCALAPPDATA%\Halterio on Windows: transcripts, settings, logs and run journals. The engine listens on localhost only, and every connection must present a token the engine minted when it started.

Which platforms does it run on?

macOS, Windows and Linux. The UI is rendered natively with gpui. The engine can also run headless on a server, managed by launchd or systemd.

When can I download it?

Installers for macOS, Windows and Linux are coming soon: a signed macOS disk image, a Windows installer with a portable build, and a Linux tarball with an install script. The app updates itself after that.

Can I control it from my phone?

Account-free remote control is on the roadmap: pair a phone or another computer by QR code, end-to-end encrypted, with per-device permissions, so a phone can approve a prompt without being able to read your files. Today, multi-device sync works through the optional self-hosted edge.

How is this different from running the CLIs in a terminal?

You can keep doing that; Halterio runs the same CLIs. What it adds is the part around them: a checkout per thread, a sidebar that tells you which agent needs you, diffs and pull requests next to the transcript, agents that can see designs, your screen and your simulators, and an MCP server that lets one agent run the others.

Where it’s going.

Three things get most of the effort next: a new shell, account-free remote control, and a phone that can approve a prompt.

v0.1, now
Runs locally
Running on macOS, Windows and Linux. Design canvas, Computer Use and Simulators are in. Installers are next.
v0.2
The Night shell
The new sidebar: attention groups, three-line thread rows, provider usage dock, titlebar search.
v0.3
Direct Link
Pair a phone or another computer by QR code. Noise end-to-end encryption, per-device scopes, off by default.
v0.4
Updater & controller
The in-app updater, and your desktop as a controller for agents running on other hosts.
v0.5
Automations & review
Runs on a schedule, on a push, or when CI fails. A review queue for everything agents changed.
v1.0
Mobile companion
Off-network relay, hardening, and a phone app that follows transcripts and answers prompts.

Installers are coming soon.

Halterio runs on macOS, Windows and Linux. The first builds ship as a signed macOS disk image, a Windows installer with a portable build, and a Linux tarball with an install script. The app keeps itself up to date after that.

macOS
Signed disk image, Apple silicon and Intel.
Coming soon
Windows
Per-user installer and a portable build.
Coming soon
Linux
Tarball with an install script and a desktop entry.
Coming soon

All your coding agents. One native window.

One thread, one checkout, everything in reach.

A worktree per thread

Answer, redirect, stop

No web view in the way

Diff, files, terminal, pull request. And three surfaces you won’t find elsewhere.

Pull requests, in scope

Design

Computer

Simulators

Agent usage

Point at an element. Say what to change.

Comment mode

Tweak sliders

Project canvas

From a sentence to a file

One agent can run the others.

Tools every thread gets

The same engine runs in the app or on a server.

Local-first

Agent accounts

Status you can trust

Appshots & voice

Thirty built-in variants. Or import yours from VS Code.

Questions, answered plainly.

Where it’s going.

Runs locally

The Night shell

Direct Link

Updater & controller

Automations & review

Mobile companion

Installers are coming soon.

macOS

Windows

Linux

All your coding agents.
One native window.