I wanted something deliberately small: not another AI, not another IDE, just a home for the agents I already use. So I built Quarters, a free, open-source (MIT) Mac app where every project gets a room. This post is about the problem, the design choices, and a few things I learned building it in Go.

Repo: https://github.com/amithgc/quarters

The problem

I work on several repos at once, and each one usually has an agent running plus a dev server or two. The agents are good at working on their own for a while, but then they stop and wait for me. With five terminal windows open, the hard part was never the typing. It was knowing which window needed me.

What Quarters does

A room per project. Switch projects in a click (⌘P). Each room keeps its agent, its terminals and its git status.

Who's waiting. When an agent is waiting for you, the project shows “◐ your turn”, and ⌘J jumps to the next one that needs you. There's a Dock badge and notifications too.

Automations. Start the whole dev stack for a project with one action instead of three terminals.

There’s also a prompt queue and saved prompts, conversation search and resume, git worktrees, and a command palette (⇧⌘P).

Bring your own agent

Quarters has no AI of its own, no accounts, no cloud and no telemetry. It runs the agent you already have installed and signed in: Claude Code, Codex, Gemini CLI, Antigravity, OpenCode, GitHub Copilot CLI, Devin or Aider, chosen per project.

Claude Code gets the deepest integration, because it keeps local logs I can read: session stats, plan usage, per-project token usage with a 14-day chart, and past conversations. The other agents get the tabs, alerts, automations, worktrees, git and remote access.

Working from my phone

The feature I use most is remote access. I start something at my desk and approve it from the sofa. It's off until you start it, it listens only on the Mac, and you reach it through a tunnel you choose (Cloudflare, Tailscale) or your home Wi-Fi. Devices are paired with passkeys from the Mac, and each device can be full, type-only or watch-only. There are rate limits and growing lockouts.

I've tried to design it to be safe to expose, and the design and its limits are written up in SECURITY.md. I'd genuinely welcome critique of it.

Building it in Go

Quarters is Go with Wails (Go plus the system WebView, not Electron) and xterm.js for the terminals. One event stream feeds both the Mac window and any browsers connected remotely.

The thing I spent the most time on was idle CPU. Early versions sat around 20% of one core. Now it's about 2% of one CPU core when idle, measured on my Mac with 14 projects. Most of the win came from two rules: only run git when something may actually have changed, and run no timers while the window is hidden.

What it doesn't do

It isn't a general-purpose terminal replacement, and it has no AI of its own. It's pre-1.0, so expect rough edges. Windows works as a browser client; the server runs on a Mac, Linux or WSL.

Try it

brew install --cask amithgc/tap/quarters

There's also a headless Linux server you use from a browser (brew install amithgc/tap/quarters-server), or you can build from source. Everything is at https://github.com/amithgc/quarters and https://quarters.amithgc.com/.

If it's useful, a star on GitHub helps other developers find it, and issues with what you'd like to see are very welcome. I'd also love to hear how you juggle multiple agents today.

Quarters is an independent project and isn't made by or affiliated with Anthropic, OpenAI, Google, GitHub or any of the agent makers.

You end up cycling through tabs to find out which agent stopped five minutes ago to ask a question, or wondering how to undo a prompt that touched twelve files without wrecking your git index, or wishing you could approve a migration from the sofa on your phone.

I built Quarters (quarters.amithgc.com) to solve that workflow for myself. It is a native macOS app (plus a headless Linux server; Windows is supported as a browser client only) and is free and open source (MIT).

Independence note: Quarters is an independent open-source project. It is not made by, affiliated with, or endorsed by Anthropic, OpenAI, Google, GitHub, or the makers of the other agents it runs.

Here is how the three core pieces work under the hood: PTY session multiplexing across desktop and mobile, zero-index-touch git checkpoints before every prompt, and passkey-paired remote access.

1. One PTY per session, shared across the Mac window and phone browsers

Quarters is built with Wails: a Go backend driving a plain ES-module JavaScript frontend (no bundler) inside the system WebView, with xterm.js rendering each terminal.

Each project gets its own "room" (internal/projects), and each tab inside a room—whether it is an agent (claude, codex, gemini, aider, opencode, copilot, devin, amp, goose, qwen, agy, or agent) or a shell—runs in a pseudo-terminal managed by Go (internal/session).

Because the Go backend owns the PTY stream:

• Multi-window & phone sync: The Mac window and any connected phone or laptop browser subscribe to the same live PTY session over a WebSocket. Whichever window you are actively typing in sets the terminal's dimensions.
• "Your turn" detection (◐ waiting): Quarters watches terminal activity and session logs so when an agent finishes a turn or pauses for input in a background project, the room gets marked and moves to the top of the ACTIVE list (sorted longest-waiting first, reachable from anywhere with ⌘J).
• In-process subagents: When launching Claude Code, Quarters passes --settings '{"teammateMode":"in-process"}' (unless you set your own --settings) and strips inherited TMUX or STY environment variables. That keeps subagents inside the tab you can see on both your Mac and your phone instead of spawning invisible tmux panes.
• Low idle footprint: Git status checks and file watchers only run when filesystem events fire, and timers pause while the window is hidden. Measured on a Mac with 14 projects open, Quarters sits at roughly 2% of one CPU core when idle in the background.

2. Snapshotting every prompt without touching your git index (refs/quarters/checkpoints/)

Every time you send a prompt to an agent, you want a clean "undo" button in case the agent goes down the wrong path—even if you had uncommitted work in your working tree before the prompt started.

Using git stash or commits on your current branch causes constant friction with your real staging area. Instead, Quarters snapshots the project before every prompt using a temporary git index:

1. Quarters copies the current index state into a temporary GIT_INDEX_FILE.
2. It stages all non-ignored working-tree files into that temporary index and writes a tree object (git write-tree).
3. It creates a commit object stored under refs/quarters/checkpoints/ (keeping the last 50 per project).

Because these commits live under refs/quarters/checkpoints/:

• Your actual branch, HEAD, staging index, and stash are never touched.
• A plain git push never uploads checkpoint commits to your remote.
• Opening the Checkpoints panel shows the exact file-by-file diff since any prompt. Clicking Restore takes a fresh checkpoint first (so even a restore is reversible) and puts your files back where they were.

Similarly, the built-in Git commit dialog refuses to stage or commit files that look like secrets (.env, *.pem, private keys)—stopping the commit and naming the blocked files before they ever reach history.

3. Remote access from a phone: passkeys, loopback listener, and origin checks

Because a terminal tab runs with your user's privileges, anyone who can type into it can run commands as you. Remote access is designed to be safe to expose; read SECURITY.md for the full threat model and implementation details.

Key design choices in internal/remote:

• Off until you start it: The HTTP/WebSocket server does not run until you explicitly start it (⌥⌘R or Remote Access → Start server). By default it binds only to 127.0.0.1 and expects to be reached through your own tunnel (such as Cloudflare Tunnel or Tailscale Funnel), so no router ports are opened.
• Paired from the Mac with WebAuthn passkeys: Clicking Pair a device on the Mac generates a QR code carrying a single-use token in the URL fragment (never logged, valid for 10 minutes, burned after 5 failed attempts). Signing in uses WebAuthn passkeys (go-webauthn) requiring device user verification (Face ID, Touch ID, or PIN) bound to your domain. If a passkey's signature counter ever moves backward—a sign of credential cloning—Quarters refuses it and alerts you on the Mac.
• In-memory SHA-256 session hashes & strict allowlists: Sessions are random 256-bit tokens kept only in memory as SHA-256 hashes (restarting Quarters signs everyone out) with __Host- prefixed, HttpOnly, Secure, SameSite=Strict cookies. Every WebSocket message re-verifies the session, checks Host and Origin headers to block DNS rebinding and cross-site WebSocket hijacking, and passes through an explicit RPC allowlist (remote_app.go) that keeps device pairing and security settings Mac-only.
• Phone-friendly cards + full terminal: On a phone browser, you can read the conversation as clean message cards, approve or reject tool prompts with a tap, queue your next prompt while the agent works, or flip to the live xterm.js view.

Try it or read the code

Quarters is free and open source (MIT):

• GitHub repository: https://github.com/amithgc/quarters
• Website & tour: https://quarters.amithgc.com
• Security architecture: SECURITY.md
• Homebrew (macOS):

  brew install --cask amithgc/tap/quarters
  

If you run multiple CLI agents across projects—or have solved terminal multiplexing and mobile approvals differently—I would love to hear what your setup looks like.