thaytool — features

persistent terminals

terminals that survive.

most apps kill their terminals when you quit. thaytool runs a detached PTY daemon in the background. close the app, reopen it, your agents are still running, scrollback and all, reattached exactly where they left off. not a tmux wrapper, the actual process, still alive, waiting for you. when the daemon itself updates, live file descriptors hand off to the new one over Unix `SCM_RIGHTS`, so not a single terminal restarts. reset any pane to a clean shell when you want one.

survives a reboot

not just quit. a full reboot.

scrollback is snapshotted to disk, so even if the machine reboots or the daemon dies, every pane replays its history when you reopen it. and if a pane was running claude code, thaytool fires `claude --resume` for you on the next launch, so the conversation comes back, not just the text above an empty prompt. (toggle it in settings.)

a git worktree per task

one task. one worktree. no collisions.

each workspace is a real `git worktree`, a separate working tree checked out from the same repo, on its own branch from the start. agents can't step on each other because they're not in the same directory. when one's done, you review the diff and merge, main stays clean until you say so. point a project at more than one repo and you get one worktree per repo under a shared folder, for monorepo splits like frontend + backend.

agents in parallel

run the whole team at once.

claude code on the auth refactor. codex on the test suite. claude code again on the api migration. three agents, three worktrees, one window. spin one up from a prompt (it becomes the branch name), pick the agent and the base branch, hit ⌘enter.

agent status it actually knows

running, needs you, or done. not a guess.

thaytool installs a claude code hook (non-destructively, next to whatever else lives in your `~/.claude/settings.json`) and reads claude's own lifecycle events, so the status is what claude actually did, not a scrape of the output. no hooks, like codex or a plain `claude` you typed yourself? it falls back to watching the terminal bell and the foreground process. a yes/no prompt turns the badge amber the moment it shows up, even mid-turn.

a menu bar that watches the fleet

the whole fleet, from the menu bar.

the menu-bar icon shows the loudest state across every workspace: amber when an agent needs you, a spinning count while they work, green when they're all done. left-click for a live popover grouped by project (search it, scan a recent-activity feed). right-click for a full menu with per-workspace open/rename/close and your open PRs with CI status.

answer from anywhere

reply without switching windows.

when an agent stops to ask, you get a real macOS notification with Reply, Yes, and No baked in. or a yes/no straight on the waiting row in the popover. or pin a floating glass HUD (⌥⌘Space) that stays on top of every space, with an auto-pop toast in the corner when something off-screen needs you. or toggle desktop pets — small on-screen companions that show an agent's status and, on hover, its actual last message with an inline reply. notifications rate-limit per workspace and coalesce a burst of parallel agents into one banner instead of ten.

tabs and split panes

more than one terminal per workspace.

each workspace has its own tab strip, and any tab splits right or down into a pane tree you can drag to resize. closed a tab by accident? ⇧⌘T brings it back, full split layout and all.

review, stage, commit, in-app

the whole git loop without leaving.

the changes panel lists every staged, unstaged, and untracked file with add/delete counts. click one for a syntax-highlighted diff. stage, unstage, discard, mark-as-viewed, write a message and commit, right there. browse the file tree, open a file in the editor, save with ⌘s.

github PRs, no browser

PR state where the work is.

every workspace with a branch polls `gh` in the background and shows its PR: draft/open/merged, the review decision, the CI rollup, who's been requested. failing checks or a changes-requested light up an attention badge on the row. the review queue pulls a PR's existing threads into a native, no-webview diff with word-level highlighting: comment on the diff, batch every note, and flush the whole batch to the agent as a single prompt instead of interrupting after each one. then squash, merge, or rebase in-app. all from the cli you already authed, no extra sign-in.

a kanban board for the fleet

todo, in progress, done — across every workspace.

capture an idea as a card and send it straight to an agent. on-device AI classifies each card to the right project and ranks workspaces for the “send to…” picker, but your manual choice always wins. cards track the live agent, surface its real question, and hold image attachments for weeks. old done cards auto-archive after 14 days, restorable.

real system data

real data. not a dashboard. not a simulation.

cpu from `mach`. listening ports from `lsof`. git status from the actual working tree. thaytool reads the OS directly, no agent to poll, no server to query. dev server on :3000? you see it, attributed to the right workspace. an agent pegging a core? you see it. (the readout pauses itself when no window is open, so it costs nothing in the background.)

make it yours

themes, fonts, flags, and an optional Metal GPU renderer.

11 terminal palettes (catppuccin, dracula, nord, gruvbox, tokyo night, and more), any monospace font, 10 to 24 pt, truecolor, an optional metal gpu renderer, all applied live. edit each agent's launch command to pass your own flags. set a branch prefix so everything lands under `you/feature-x`. ⌘p fuzzy-searches every workspace, file, and action; `thaytool://` deep links jump straight in.

setup that rides with the repo

`.thaytool/`, committed alongside the code.

drop a `.thaytool/config.json` with `setup` and `teardown` commands and every new workspace runs your setup (`bun install`, migrations, whatever) in the pane before the agent starts, and your teardown (`docker compose down`) before it's deleted. a gitignored `config.local.json` overlays per-machine steps without touching the team's.

native macOS, single binary

SwiftUI. macOS 26 Liquid Glass. one binary.

no electron. no node runtime bundled inside a shell script. it ships as one signed, notarized binary and behaves like a Mac app because it is one. it updates itself in the background (Sparkle, EdDSA-signed), with a canary channel in settings if you like living early. uninstall it and it's gone.

100% local

your work stays on your machine.

no cloud backend. no auth server. no account to create. no api key to revoke if the company pivots. your repos, terminals, and agent sessions never leave the machine, not because of a privacy policy, but because there is nowhere for them to go. the daemon speaks over a local Unix socket, so the app opens zero TCP ports, and its one stored secret lives in the macOS Keychain only. every AI feature runs on Apple's on-device models and fails closed to deterministic behavior. terminal hyperlinks are allowlisted to http/https/mailto/ssh, and replayed scrollback is scrubbed of escape-sequence queries, so a rogue program can't probe your shell. single-user, fully local, deliberately scoped.

how it works

1. 1. add a repo
   point thaytool at a git repo on your disk. it reads the current state (branches, worktrees, uncommitted changes). that's the whole setup.
2. 2. create a workspace
   pick a task, name a branch. thaytool checks out a new git worktree for it, sandboxed so it can never touch your main checkout, and opens a persistent terminal inside it.
3. 3. run your agent
   drop into the terminal and start claude code or codex. switch to another workspace and do it again. thaytool tracks diffs, ports, and metrics while you work.
4. 4. review, or walk away
   review the diff and merge when you're ready. or close the laptop and come back tomorrow, the terminals will still be running.

questions

$ how to get it