Quarters

A minimalist home for terminal coding agents, for developers who work on many projects at once.
Claude Code, Codex, Gemini CLI, Antigravity, OpenCode, Copilot CLI, Devin or Aider: switch projects in a click,
run your agents in several of them side by side, see what they're doing,
start your dev servers with one action — and do it all from your phone, too.

brew install --cask amithgc/tap/quarters

_{Free and open source · quarters.amithgc.com · If Quarters saves you some tab-hunting, a ⭐ helps other developers find it.}

Install · Features · Coding agents · Remote access · Configuration · FAQ · Contributing

Why Quarters

If you use a terminal coding agent — Claude Code, Codex, Gemini CLI, Antigravity, OpenCode — on more than one project, you know the routine: a terminal window per project, cd into each one, start the agent, start the backend, start the frontend, then remember which window was waiting for you.

Quarters is a simple, focused home for your coding agents that takes that routine away. Pick the agent you like (Claude Code is the default, and each project can use a different one). Its goals are deliberately narrow:

1. Switch between projects instantly. Every project is one click (or ⌘P) away; its agent sessions keep running in the background while you're elsewhere.
2. Work on several projects at the same time. Agents run in as many projects as you like, and Quarters tells you which one finished and is waiting for you.
3. See what's going on at a glance. A side panel shows git changes, the project's automations and servers, and what the agent tells Quarters: for Claude Code the session's model, context and tokens, your plan's usage, what it edited, and the project's MCP servers and skills; for Antigravity its plan and model quotas.
4. Start the rest of your stack in one go. Automations open the terminals a project needs — backend, frontend, a script, a watcher — each in its own folder, side by side, when you open the project, on a schedule or with one click.
5. Do the daily chores where you work. Commit, push and open pull requests (with CI status), run a project's scripts, stop the dev server holding a port, undo an agent turn that went wrong, search every project at once, and copy a summary of your day.
6. Work from anywhere. Leave Quarters running on your big machine at home and use it from a laptop, tablet or phone through the browser: the same projects, the same live sessions, secured with passkeys.

It is built for developers and their coding agents, and nothing else: no general-purpose terminal features, no AI of its own, no accounts or cloud services. Your projects, your logins and your machine stay yours.

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. Claude and Claude Code are trademarks of Anthropic; the other names are trademarks of their owners.

Features

Home: every project at a glance

The house at the left of the title bar (or Home in ⇧⌘P) shows the home page, with your tabs still running behind it:

• Jump to a project, add one, search conversations, Settings: one tile each, with its shortcut. A different tagline greets you every time.
• Today, across every project: sessions, tokens written and read, and the cache hit rate, with the last two hours as an animated chart (bars rise in, the current five minutes glow; hover one for its time and tokens).
• Today's work: per project, your commits since midnight, the agent conversations you had and how many prompts, and what isn't committed yet. Copy puts it on the clipboard as Markdown, for a standup or a timesheet (also ⇧⌘P → Copy today's summary).
• Active now: every running session, the ones waiting for you first.

Projects, tabs and sessions

• One click opens a project; press C to start its coding agent, ⇧C to continue the last conversation, S for a shell.
• Several tabs per project (agents and shells), all running in the background while you switch.
• Images in the terminal: a path to an image an agent made (or any PNG, JPEG, GIF or WebP a tab prints) is a link: hover to preview it, click to see it full screen.
• "Your turn" alerts: when an agent finishes in a tab you aren't looking at, you get a notification and a Dock badge, and the tab is marked.
• Who's waiting for you: the ACTIVE list (with 5 projects or more) puts the sessions that finished (or are asking you something) first, longest waiting first, with how long; ⌘J (or a click on "◐ waiting" in the title bar) goes to the next one.
• Prompt queue: line up prompts for a session ("add tests", then "fix lint"…); each goes in when the agent finishes the one before, never over a question it is asking or a message you started typing. On a phone, ⏭ in the message card queues what you typed while the agent works.
• Groups, project icons, drag to reorder, ⌘P / ⇧⇧ to jump anywhere, git status (●changes ↑ahead ↓behind) in the list, and ＋ add in the list's header.
• Project icons: an image (favicons and app icons in the folder are suggested), or any emoji from Emoji…, every emoji there is, by group and with a search by name.
• A colour per project on its tabs and the terminal's frame, so you can tell projects apart at a glance (from its name, or one you pick).
• Every command by name: ⇧⌘P (or > in the jump list).
• Focus mode: ⇧⌘↵ leaves only the terminal; again brings the panels back.
• Tips: one quiet line at the bottom right about a key or a panel, the ones you haven't used first. The next one fades in every two minutes; › shows it now.
• Saved prompts (⚡): type a common instruction with one click.
• The project's automations in the side panel: run, restart or stop each one, edit it, delete it, or add a new one, right where you work.
• Any of twelve coding agents, chosen for all projects or per project (see Coding agents).

Split panes and a files panel

• Split panes, as in iTerm: ⌘D opens a shell beside the one you're in, ⇧⌘D one below it, and splits nest. ⌘[ and ⌘] move between panes, ⌘W closes just the pane, and a pane whose shell exits cleanly closes by itself. Drag the line between two panes to resize them (double-click to make them equal). Another window or device shows the same panes.
• A files panel (⇧⌘E, or the folder in the title bar, which glows while it's open): the project's folders and files with git's marks (changed, new, ignored), and a box that finds any file in the project. Right-click a file to copy its path, type it in the terminal, open it with its app or show it in Finder.
• A small editor for quick fixes: click a file to open it in a tab beside the terminals, with syntax colours for about 30 languages, search (⌘F) and ⌘S to save. When an agent edits the same file, the editor follows it; a save never overwrites a change made since you opened the file (you choose to reload or keep yours). Files that may hold keys or passwords (.env, *.pem…) are never opened.

Everyday developer tools

The chores around an agent's work, without leaving the project.

• Commit, push and pull requests: Commit… under the changed files in the side panel's GIT section opens a dialog with the files and a message box; ✨ Draft it asks Claude Code (claude -p) to write the message from the diff, in the style of your recent commits, and nothing is committed until you click. Commit & push does both; Push ↑2 pushes what's ahead (setting the upstream the first time); Open a pull request runs gh pr create --fill. Files that look like they hold secrets (.env, keys…) are never committed: the commit stops and names them.
• CI at a glance: the branch's pull request shows under the files with its checks: ✓ passed, ● running, ✕ failed (and which). It's read with the GitHub CLI (gh), about once a minute.
• Scripts, one click away: the SCRIPTS section lists what the project knows how to run: package.json scripts (with pnpm, yarn, bun or npm, from the lockfile), Makefile targets, justfile recipes, deno.json tasks, and Cargo and Go commands. A click runs one in a tab of its own; a running one is marked and goes to its tab. In ⇧⌘P, run dev runs it too.
• Ports: the PORTS section lists what the project's tabs are listening on (:5173 node · web), and other processes of yours working in its folder. open opens it in the browser, tab goes to the tab that started it, stop ends it ("port 3000 is already in use", solved).
• Checkpoints before every prompt: each time you send an agent a prompt, Quarters quietly snapshots the project's files (everything git doesn't ignore, committed or not). The CHECKPOINTS section lists them with what changed after each; open one to see every file's diff since, and restore to put the files back as they were. Restoring takes a checkpoint first, so it can be undone too. Your branch, index and stash are never touched: checkpoints are commits kept under refs/quarters/checkpoints/, the last 50 per project, and a plain git push doesn't send them anywhere.

• Clickable errors: src/cart.ts:42:7 (or file.py:12, File "x.py", line 3, Foo.cs(10,5)) in any terminal is a link when the file is in the project: ⌘-click opens it in the editor at that line.
• Send to agent: select output in a terminal, or lines in the editor, and press ⇧⌘L (or the button that appears): it's typed into the project's agent tab, with the file and line numbers from the editor, but not sent, so you can say what to do with it.

• Search every project (⇧⌘K): one box searches the files of all your projects at once, with ripgrep when it's installed (git grep otherwise). Match case, whole words, regular expressions and a file filter (*.go); results by project and file, and Enter opens the file at the line. Files that may hold secrets are never searched.

Coding agents

Choose the default in Settings → Coding agent, and per project from the side panel's Agent menu (or ✎ on the project). Agents that aren't installed are marked, and starting one tells you where to get it.

Agent	Starts	Continue (⇧C)	Skip permission prompts (yolo)	Side panel
Claude Code (default)	claude	--continue	--dangerously-skip-permissions	everything below
Codex	codex	resume --last	--dangerously-bypass-approvals-and-sandbox	git, automations
Gemini CLI	gemini	--resume latest	--yolo	git, automations
Antigravity	agy	--continue	--dangerously-skip-permissions	plan and model quotas¹, git, automations
OpenCode	opencode	--continue	— (set in its own config)	git, automations
GitHub Copilot CLI	copilot	--continue	--allow-all-tools	git, automations
Devin	devin	--continue	--permission-mode bypass	git, automations
Aider	aider	--restore-chat-history	--yes-always	git, automations
Amp	amp	threads continue --last	--dangerously-allow-all	git, automations
Goose	goose	session --resume	— (GOOSE_MODE=auto in its config)	git, automations
Qwen Code	qwen	--continue	--yolo	git, automations
Cursor CLI	agent	--continue	--force	git, automations

Claude Code gets the deepest integration, because Quarters reads its session logs: session stats, plan usage, past conversations, the phone's chat view and Remote Control. Other agents run as they are, in their terminal (on a phone with the same message card as Claude), with everything else Quarters does — tabs, alerts, automations, worktrees, git, remote access — working the same.

¹ Read from the Antigravity IDE while it's open on the same machine, through its local (unofficial) interface; nothing leaves the machine.

Agent teams (Claude Code) run inside the tab. Quarters starts Claude Code with --settings '{"teammateMode":"in-process"}', so teammates run in the agent's own terminal (↓ from an empty prompt manages them), on the Mac and in a browser alike. With "teammateMode": "tmux" in your Claude Code settings they would open in tmux panes no Quarters window shows, or fail with "To use agent swarms, install tmux". A --settings of your own in the project's command is left alone. Tabs also don't inherit the TMUX (or screen) variables of a terminal Quarters was started from, so no agent thinks it's inside tmux when it isn't.

Automations: your dev stack in one action

An automation opens a set of terminals, each in its own folder and running its own command, arranged as a grid, side by side, stacked or as tabs. Run it by hand (▶), when the project opens, or on a schedule (every weekday at 09:00, say). Servers your terminals start show up in the side panel with whether they're answering.

The side panel: what your agent is doing

Plan: Claude's usage limits and when they reset, as /usage shows them, with a warning before you run out (Antigravity: its plan and model quotas). Agent and Automations: the project's coding agent, and its automations with run, stop, edit, delete and ＋ new. Session: title, model, permission mode, prompts, context window use, tokens (this session or today) and activity. Git: branch, ahead/behind, changed files, Commit…, Push and Open a pull request, and the pull request's checks. Claude changed: the files Claude edited this session; click one for its diff. Servers: localhost links your terminals printed, up or down. Scripts and Ports: the project's scripts to run in a tab, and what its tabs listen on, to open or stop. Checkpoints: a snapshot before each prompt, to diff against or restore. Usage: the project's tokens today, over 7 and 30 days, and its share of yours; ⇧⌘U ranks every project (from Claude Code's logs). Instructions: edit the project's CLAUDE.md, AGENTS.md, GEMINI.md or CONVENTIONS.md (the one its agent reads is offered even before it exists), and your own notes on the project, kept by Quarters outside the project folder. Click a section's title to fold it to one line; the bar above the panel jumps to a section or folds them all. Each device remembers its own. Tools, MCP servers and skills available in the project. Claude Remote Control: a switch that starts new Claude tabs with Claude Code's own Remote Control, so you can also continue them from claude.ai/code and the Claude app.

Past conversations, restarts and worktrees

• Search past conversations (🕘 / ⇧⌘F): everything you and Claude said in a project; open one to resume it.
• Pick up where you left off: after a restart (or a crash), Quarters offers to reopen every conversation and automation that was running.
• Git worktrees (⎇ / ⇧⌘G): start Claude on a separate copy of the project, on its own branch, so several can work on the same repository without stepping on each other.

Settings: switch off what you don't need

Every optional feature has a switch (checkpoints, scripts and ports among them), and Claude's permission mode can be set globally or per project. Appearance picks light, dark or the system's look, on each device.

Remote access: work from anywhere

Run Quarters on the machine that has your code (a desktop at home, a Mac mini in a cupboard) and use it from any browser: your laptop on the road, an iPad, your phone. You see the same live sessions: start Claude on the Mac, answer it from your phone, finish on the laptop. On a phone, every coding agent gets the same session view: its transcript above, and a message card below (the one place to type, with ↑ send, ■ stop and the tab tools), the same for Claude Code, Codex and the rest. Claude Code's transcript reads like the Claude app: a chat with your messages, its replies, folded tool rows, the images it sends and buttons for its questions (▤ shows the terminal). Other agents show their terminal. Installs as an app on your phone's home screen, with a key bar for the keys a phone lacks (esc, tab, ⇧tab, ctrl, arrows) and saved prompts. Phone alerts when Claude is waiting, even with the app closed. Passkeys (Face ID / Touch ID) to sign in. Devices can only be paired from the Mac, and each device can be limited to type only or watch only. Start and stop the server from the app (⌥⌘R).

Install

Requirements: macOS 11 or later (or Linux, or Windows through WSL, for the server, below), and at least one coding agent installed and signed in, on your PATH: Claude Code (claude, the default) or one of the others. Quarters is developed and tested on current macOS on Apple silicon; the app is universal (Apple silicon and Intel).

With Homebrew:

brew install --cask amithgc/tap/quarters

The app is signed with a Developer ID and notarized by Apple, so it opens like any other. brew update && brew upgrade --cask quarters updates it. You can also download the zip from the releases.

Building from source

You need Go 1.26+, Node.js 20+ and the Wails CLI:

go install github.com/wailsapp/wails/v2/cmd/[email protected]

git clone https://github.com/amithgc/quarters && cd quarters
make install        # builds Quarters.app and copies it to /Applications

make build builds it into build/bin/Quarters.app without installing. For an Intel Mac use wails build -platform darwin/amd64. A build of your own is signed ad hoc, so the first time macOS may ask you to confirm opening it (right-click → Open).

Releasing (maintainers): scripts/release.sh 1.2.3 publishes a version from a Mac: it signs and notarizes the app, publishes the GitHub release and updates the Homebrew tap. Its header lists the one-time setup.

Linux: the server, used from a browser

On Linux, Quarters runs as a server with no window: leave it on the machine that has your code (a home server, a big desktop, a box in a cupboard) and use it from a browser or the phone app. Everything the browser version does works: projects, Claude and shell tabs, automations, the chat view on phones, plan usage, past conversations and worktrees. The Mac-only extras (the window, the Dock badge, the global hotkey) are left out.

It is a single file with no dependencies besides your coding agent and git. Install it with Homebrew on Linux (brew install amithgc/tap/quarters-server), download it from the releases (quarters-linux-amd64.tar.gz or -arm64), or build it (on any machine) and copy it over:

git clone https://github.com/amithgc/quarters && cd quarters
make server          # build/bin/quarters-linux-amd64 and quarters-linux-arm64
scp build/bin/quarters-linux-amd64 my-server:/usr/local/bin/quarters

Then, on the server:

quarters --set-password amith   # the username and password to sign in with
quarters                        # start the server (it prints its addresses and a pairing link)

Add your projects from the browser (＋ add) once signed in, or list them in ~/.config/quarters/config.json. To open it on your home network, set "remote": {"lan": true} there; to reach it from anywhere, put a tunnel in front (see Remote access setup). Plan usage is read from ~/.claude/.credentials.json, where Claude Code keeps its login on Linux.

Managing it without a window:

command	does
quarters --set-password NAME	set (or change) the username and password; signed-in browsers sign in again
quarters --pair	a one-time link that pairs a device with a passkey (HTTPS or localhost only)
quarters --devices	list the paired devices and the password sign-in
quarters --remove-device NAME	unpair a device (by name or id); it is signed out at once
quarters --version	which Quarters this is, e.g. Quarters 0.7.0 (linux/amd64, server); worth adding to a bug report
quarters --help	all of the above

To keep it running, a systemd user service works well:

# ~/.config/systemd/user/quarters.service
[Unit]
Description=Quarters

[Service]
ExecStart=/usr/local/bin/quarters
Restart=on-failure

[Install]
WantedBy=default.target

systemctl --user enable --now quarters
loginctl enable-linger $USER    # keep it running when you're logged out

Docker: the server in a container

The docker/ folder has a Dockerfile and a compose.yaml that run the Linux server with Claude Code inside, as a normal user (Claude Code won't skip its permission prompts as root). Your projects live in a folder you mount, and settings, sign-ins and conversations in a volume, so they survive updates.

git clone https://github.com/amithgc/quarters && cd quarters/docker
mkdir -p code                       # your projects go here (or set CODE_DIR=/path/to/code)
docker compose build
docker compose run --rm quarters quarters --set-password amith   # username and password
docker compose up -d

Open http://localhost:8421 (or http://<the machine's IP>:8421 from another device on your network) and sign in. Then:

1. Sign Claude Code in, once: docker compose exec quarters claude, then /login; it prints a link to open in any browser and asks for the code it shows. The login stays in the volume.
2. Add projects from the browser (＋ add): folders under code/ are at /home/dev/code/… in the container. To clone one there: docker compose exec quarters git clone https://github.com/you/app code/app.
3. Git: set your name and email once (docker compose exec quarters git config --global user.name "You", and user.email), or mount your ~/.gitconfig; mount ~/.ssh to push over SSH (both are in compose.yaml, commented out).

Good to know:

• Your user id: files Quarters writes in code/ belong to user 1000. If your id (id -u) is different, build with QUARTERS_UID=$(id -u) docker compose build.
• Ports: keep both numbers in "8421:8421" the same; the server checks the address it is reached at.
• Changing the password: run the --set-password line again, then docker compose restart.
• The home network only: the container answers plain HTTP from private addresses (your network, Tailscale), never from the internet. For HTTPS and passkeys, put a tunnel in front: set QUARTERS_URL in compose.yaml to its address (e.g. https://quarters.example.com) before the first start, and point the tunnel at http://localhost:8421 (cloudflared tunnel run --url http://localhost:8421 quarters, or tailscale serve --bg 8421). If the settings already exist, add "url" under "remote" in ~/.config/quarters/config.json (docker compose exec quarters vi …, or edit it in the browser) and restart.
• Other agents: install them in the image (add a RUN line to the Dockerfile, e.g. npm i -g @openai/codex after adding Node.js).
• Updating: change QUARTERS_VERSION in compose.yaml, then docker compose up -d --build. Claude Code updates itself.

On Windows, the same files run in Docker Desktop (with its WSL 2 backend, the default). In PowerShell:

git clone https://github.com/amithgc/quarters; cd quarters\docker
mkdir code
docker compose build
docker compose run --rm quarters quarters --set-password amith
docker compose up -d

and open http://localhost:8421 in Edge or Chrome. Keep your projects in the container's code folder (clone them there with docker compose exec, as above) rather than pointing CODE_DIR at a folder on C:\: Windows folders mounted into a container work, but git and file watching are slow on them. The user id note above doesn't apply. Or skip Docker and run the server in WSL directly (next section).

Windows: the server in WSL

On Windows, run the Linux server inside WSL (wsl --install in an administrator PowerShell, then open Ubuntu), with Claude Code and your projects in WSL too. Follow the Linux steps above inside Ubuntu, start quarters, and open http://localhost:8421 in Edge or Chrome on Windows: WSL passes localhost through, so passkeys (Windows Hello) and installing it as an app work. To reach it from a phone, turn on WSL's mirrored networking and the home network. The install guide has every step. Prefer a container? See Docker, which has the Windows steps too.

Getting started

1. Open Quarters. The first time, it lists the folders you used Claude Code in most recently (if you use it). Add others with ＋ add (⌘O). If your projects are in Documents, Desktop or on an external drive, macOS asks whether Quarters may access them: allow it, or the project list stays empty.
2. Click a project and press C. Its coding agent (Claude Code unless you chose another in Settings) starts in that folder.
3. Add an automation for your dev servers: right-click the project → Automations → ＋ Add automation.
4. ⌘, opens Settings. Projects → Remote Access… sets up remote use.

Keyboard shortcuts

keys	action
⌘/	all keyboard shortcuts (Help → Keyboard Shortcuts)
click, then C / ⇧C / S	open a project, then start Claude / continue / a shell
⌘P or ⇧⇧ (tap Shift twice)	jump to a project or automation
⇧⌘P	every command, by name
⌘T / ⇧⌘T / ⌥⌘T	new Claude tab / continue last conversation / shell tab
⌘W	close tab (in a split: the pane)
⌘1–9, ⇧⌘[ ⇧⌘]	switch tabs
⌘D / ⇧⌘D	split: a shell beside / below this one (⌘[ ⌘] switch panes)
⌘J	go to the session waiting for you longest
⌘B / ⌘I	show or hide projects / side panel
⇧⌘E	show or hide the files panel; a click opens a file in an editor tab, ⌘S saves
⇧⌘↵	focus mode: only the terminal
⌘O	add a project
⌘, / ⌥⌘,	Settings / edit config.json
⇧⌘F / ⇧⌘G	search past conversations / worktrees
⇧⌘K	search every project's files
⇧⌘L	send the selection (terminal or editor) to the agent
⌘-click a file:line	open it in the editor at that line
⇧⌘U	usage by project
⌥⌘R	start or stop the remote-access server
⌃⌥Space (from any app)	bring Quarters forward, or hide it
⌘= / ⌘- / ⌘0	text size
⌘K	clear the terminal

Also: Shift+Enter adds a new line in Claude Code; drop files on a terminal to type their paths; hover [Image #N] to see a pasted image; double-click a tab to rename it. Light and dark mode follow macOS, or pick one in Settings → Appearance (each device keeps its own).

Remote access setup

Remote access is off until you start it, and it gives whoever signs in a shell on your Mac. Read SECURITY.md for how it is protected. In short, Quarters only listens on 127.0.0.1, and you choose the tunnel that gives it a public HTTPS address.

1. Give the Mac an HTTPS address with a tunnel. With Cloudflare and your own domain:

   brew install cloudflared
   cloudflared tunnel login
   cloudflared tunnel create quarters
   cloudflared tunnel route dns quarters quarters.example.com
   cloudflared tunnel run --url http://127.0.0.1:8421 quarters
   

   Or with Tailscale: tailscale funnel 8421, then use the https://….ts.net address it prints.

2. In Quarters, Projects → Remote Access…: enter https://quarters.example.com and press Start server.

3. Pair a device… and scan the QR code with your phone. It creates a passkey on the phone.

4. On the phone, add the page to the home screen. From then on, open it and sign in with Face ID.

No tunnel? Leave the public URL empty and press Start server: Quarters is then at http://localhost:8421, which another computer can reach through SSH (ssh -L 8421:localhost:8421 your-mac, then open http://localhost:8421 and the pairing link there). Phones need the tunnel.

At home, without a tunnel: turn on Home network in Remote Access and set a username and password there. Phones and computers on the same Wi-Fi then open http://<the Mac's IP>:8421 (the dialog shows the addresses and a QR code) and sign in with the password, since passkeys don't work on a plain IP address. The connection isn't encrypted, so keep it to networks you trust. iPhones can add it to the home screen as is. Android's Chrome installs web apps only from secure addresses, so on the home network tell it to trust this one, once: in chrome://flags/#unsafely-treat-insecure-origin-as-secure enter the address (e.g. http://192.168.1.20:8421), set it to Enabled and relaunch; then ⋮ → Install app. The sign-in page shows these steps on Android.

For a Mac with no screen, Quarters.app/Contents/MacOS/Quarters --serve runs only the server (it uses the same settings and prints a pairing link); the commands in Linux (--set-password, --pair, --devices, --remove-device) work there too.

Configuration

Settings and projects live in ~/.config/quarters/config.json. Most of it is edited from the app, but you can also edit the file (⌥⌘,): on the Mac in your text editor, in a browser in Quarters' own editor, which won't save a mistake or a change to remote access. Quarters picks up changes within seconds, and tells you if the file has a mistake without ever overwriting it.

{
  "projects": [
    { "name": "Shop", "path": "~/code/shop", "group": "Work", "icon": "web/favicon.svg",
      "automations": [
        { "name": "Start dev", "layout": "columns", "auto": true,
          "schedule": { "at": "09:00", "days": ["mon", "tue", "wed", "thu", "fri"] },
          "tabs": [
            { "name": "api", "dir": "backend", "command": "npm run dev" },
            { "name": "web", "dir": "web",     "command": "npm run dev" },
            { "name": "shell" }
          ] }
      ] },
    { "path": "~/code/api-gateway", "group": "Work", "command": ["claude", "--model", "sonnet"], "yolo": false },
    { "path": "~/code/ml", "harness": "codex" }
  ],
  "yolo": true,
  "shell": "/bin/zsh"
}

field	meaning
projects[].path	project folder (~ allowed); required
projects[].name	label in the list (default: the folder name)
projects[].group	heading to group projects under
projects[].icon	image next to the project (png, jpg, svg, ico, webp; relative = inside the project), or an emoji, e.g. "🚀"
projects[].color	colour of its tabs and terminal frame: #rrggbb or accent (default: from its name)
projects[].harness	the coding agent for this project, overriding harness
projects[].command	how the project's agent starts in this project
projects[].yolo	true/false: skip the agent's permission prompts here, overriding yolo
projects[].automations	terminals to start together (see below)
harness	the coding agent new tabs start: claude (default), codex, gemini, antigravity, opencode, copilot, devin, aider, amp, goose, qwen or cursor
command	how Claude Code starts (default ["claude"])
yolo	skip the agent's permission prompts (default true; see below)
shell	shell for shell tabs (default $SHELL)
prompts	saved prompts for ⚡ (edited in Settings)
features	optional features switched on or off (Settings), e.g. {"checkpoints": false}
hotkey	global hotkey, e.g. ctrl+alt+space
usage_alert_at	warn when a plan limit passes this percentage (default 80)
context_window	tokens; 0 = read from Claude Code's model setting
remote	remote access (set in the app)
layout	panel widths and folded groups, saved as you change them

Automations: layout is grid (default), columns, rows (all terminals as panes of one tab, resizable) or tabs. dir is relative to the project. command is typed into a login shell once it's ready, so Ctrl+C leaves you in that shell and ↑ runs it again. auto runs it when you open the project. schedule runs it by itself once a day, unless it's already running.

About yolo. By default Claude Code runs with --dangerously-skip-permissions, so it edits files and runs commands without asking. That's convenient in your own projects and risky anywhere else. Turn it off in Settings, or per project.

Other agents get their own switch: Codex --dangerously-bypass-approvals-and-sandbox, Gemini CLI --yolo, Antigravity --dangerously-skip-permissions, Copilot CLI --allow-all-tools, Devin --permission-mode bypass, Aider --yes-always, Amp --dangerously-allow-all, Qwen Code --yolo, Cursor CLI --force (OpenCode and Goose have none; set it in their own config). "Continue" runs codex resume --last, gemini --resume latest, agy --continue, opencode --continue, copilot --continue, devin --continue, aider --restore-chat-history, amp threads continue --last, goose session --resume, qwen --continue or agent --continue.

How it works

Quarters is a Wails app: a Go backend with a plain JavaScript frontend in the system WebView.

• Each session runs in a pseudo-terminal on the Go side (internal/session), and xterm.js draws it. Every window, the Mac's and any browser's, shows the same sessions; whichever one you're typing in sets the terminal's size.
• Each coding agent is a program started in a pseudo-terminal with its own switches (internal/config/harness.go).
• The side panel reads Claude Code's own session logs in ~/.claude/projects (internal/stats). Plan usage comes from the endpoint /usage uses, with the login Claude Code keeps in the Keychain, which is only ever sent to Anthropic.
• The developer tools run your own programs: git for commits and checkpoints (snapshots go through a temporary index, so yours is never touched), gh for pull requests and checks, claude -p for a drafted commit message, lsof (or ss) for ports, and rg (or git grep) for search.
• Remote access (internal/remote) is an HTTP server with passkey (WebAuthn) sign-in and a WebSocket carrying the same calls and events the Mac window uses.
• Idle, it stays out of the way: git runs only when something may have changed, files are read again only when they change, the project list is pushed to windows when it changes, and nothing on a timer runs while the window is hidden. Measured on a Mac with 14 projects, idle in the background: about 2% of one CPU core.

main.go, app.go, …     the app: window, menus, the functions the frontend calls
internal/config        config.json
internal/projects      the project list and icons
internal/session       pseudo-terminals
internal/stats         Claude Code logs, git, plan usage (Claude, Antigravity), conversations, skills
internal/remote        remote access: passkeys, sessions, WebSocket, push
frontend/dist          the frontend (plain ES modules, no bundler; ui/ holds the dialogs, loaded when first opened)
tools/mascot           draws the mascot

FAQ

How is this different from tmux? tmux can hold all the sessions, and with enough scripts it can do much of the rest. Quarters is what those scripts would add up to, without writing them: a list of your projects with their git status, an agent started in one key, a mark on the session that finished and is waiting for you (⌘J goes to it), a side panel with the session's model, context, tokens, plan usage and the files the agent changed, automations that start the dev servers with the project, and the same live sessions in a phone's browser, signed in with a passkey. If you live in tmux and like it there, keep it; Quarters is for people who'd rather click a project than remember a session name.

Why not tabs in iTerm2, Ghostty, Warp or the Terminal? A terminal knows about shells, not projects or agents. Tabs don't tell you which agent is done, can't start a project's backend and frontend together, and can't be picked up from your phone. Quarters keeps one place per project (its agent tabs, shells and servers) and leaves the general terminal work to your terminal.

What about apps that run many agents on one repository? Several tools run a team of agents in parallel worktrees of a single repository. Quarters starts from the other end: many projects, each with the agent and the dev stack it needs, and quick switching between them. It does worktrees too (⎇), when you want several agents on one repository.

Is it an editor? No. The files panel and its editor are for a look or a quick fix (a config value, a line the agent got wrong) without leaving the project. Keep your editor for real work; Quarters follows its changes on the disk the same way it follows the agent's.

Does my code or my prompts go anywhere? No. Quarters has no AI of its own, no accounts and no analytics. It starts the agents you installed, with their own logins, and they talk to their providers as they always do. Remote access is off until you start it, and then it only listens on this Mac (see SECURITY.md).

Does ✨ Draft it send my code anywhere? Only when you click it: it runs your own Claude Code (claude -p) with the diff of the commit (files that look like they hold secrets left out), the same as asking it in a terminal, and uses your plan the same way.

Where do checkpoints live, and do they get pushed? In the project's own git repository, as commits under refs/quarters/checkpoints/ (the last 50). They aren't on any branch, so git push doesn't send them; git for-each-ref refs/quarters lists them, and switching Checkpoints off in Settings stops new ones.

Does it work with my Claude subscription or API key? Yes: it runs claude (or another agent) exactly as you would in a terminal, signed in however you signed it in.

Do sessions keep running when I quit Quarters? No, the agents run inside Quarters. When it starts again, it offers to reopen the conversations and automations that were open, and Claude Code picks each conversation up where it left off. To keep agents running while you're away, leave Quarters running on that machine (or run the server on a Linux box) and use it from a browser.

Contributing

Contributions are welcome. See CONTRIBUTING.md for setup and guidelines:

make dev       # run with live reload
make test      # go test -race ./...
make lint      # gofmt, go vet, staticcheck

Please report security problems privately, as described in SECURITY.md.

Credits

Built with Wails, xterm.js, JetBrains Mono, go-webauthn and the other libraries in THIRD_PARTY_NOTICES.md. The mascot is original to Quarters.

License

MIT © 2026 Amith