Run as many coding agents as you like. Approve a command, pick an option, or land on the exact terminal tab. The agent gets its answer straight back down the channel it asked on, so nothing is ever typed into a window you cannot see.

Get for Mac How to install

macOS 15 or later. Works with or without a physical notch.

Answering an agent shouldn't cost you your focus.

Check what your agents are doing without leaving what you are doing. Status, progress and how much context each one has left, live in the notch.

An agent that is blocked is silent.
So is one that finished.

That is what running more than one actually costs. Nothing announces itself, so the watching falls to you: which one stopped, what it is asking, how much room it has left, whether it is still going at all. Crew Tower does the watching, at the top of the screen you are already looking at.

Right now

checkout-api checkout-api api-gateway storefront
~/checkout-api $ claude · Editing src/routes/checkout.ts · Running tests

Four tabs, two of them the same project. You can read exactly one of them at a time, and the one that has been waiting six minutes for you is not it. So you go looking, and lose what you were doing.

With Crew Tower

checkout-api
Bash · rm -rf build/
6m

It leans out of the notch instead, names the session, shows what it is asking for and how long it has been asking, and goes back up. You answer it there or you do not, and either way you knew.

  • You cannot see which one is stuck.

    A session waiting on you sorts above every session still working, and the collapsed bar carries one mark per agent wearing a count of that brand's sessions that want something - three Claude runs are one mark and one number, not three identical dots.

  • A ping is a doorbell, not an answer.

    Knowing that something happened still costs you the trip. The card carries the request itself - the shell command, the file being written, the hunks of an edit, the question and the options it offers - and a tool the notch cannot render in full is never given an Allow button.

  • A finished run is one nobody is watching.

    The minutes between an agent going quiet and you noticing are pure waste. When a working session ends its turn the notch leans out by itself and says so, then collapses - you find out because it told you, not because you went to check.

  • Context runs out with no warning at all.

    An agent that fills its window mid-task takes the thread with it. Every card wears a ring that turns amber past 70 per cent and red past 90, and it works out a 200k window from a 1M one rather than assuming, so a long run is something you see coming.

  • An alert that keeps firing is one you stop reading.

    So it de-escalates on purpose: it announces once, settles into a mark quiet enough to ignore, nudges a few times on a decaying schedule and then goes silent for good. Never while that session's own terminal is the window in front of you, never over a locked screen, and never while you are away from the machine.

  • Two agents in one folder look like one agent.

    That is the case it was built for. Every run is its own card - its own project, its own status, its own tab - and a jump is matched on the title the agent wrote for itself, so a second agent in the same directory never folds into the first and clicking it still lands on the right one.

Install

Four steps, then never again.

  1. 01

    Download and drag it to Applications

    A single app, around 10 MB. No installer, no helper daemon, no login item you did not ask for. Deleting it is deleting the app.

  2. 02

    Let macOS check it on first launch

    Crew Tower is not distributed through the App Store, so the first time you open it macOS may say it cannot verify the developer. Open System Settings › Privacy & Security, scroll to the message about Crew Tower and choose Open Anyway. macOS asks once, then never again.

  3. 03

    Install the hooks

    One click merges observation hooks into your agent's config - ~/.claude/settings.json, ~/.codex/hooks.json, ~/.cursor/hooks.json and friends. Only the agents you actually have are touched. A backup is written next to each, and Crew Tower repairs anything that drifts on every launch.

  4. 04

    Work exactly as you do now

    Start agents in whatever terminal you like. They appear in the notch the moment they run. When one blocks, you press Allow and its decision goes straight back down the channel it asked on - no terminal focus, no synthetic keystroke, nothing typed into a window you cannot see.

Features

Everything it does.

checkout-api 12m 42%
Bash · rm -rf build/
rm -rf build/
Deny Allow Jump

Approve without touching the terminal. The agent's hook blocks on a local socket and your decision travels back down it, resolving the prompt in place - there is no keystroke path in the app at all.

checkout-api
Bash · rm -rf build/
Deletes files recursively
rm -rf build/

It flags the dangerous ones. A destructive shell command is called out on the card before you press anything, so a fast Allow stays a safe Allow.

Deny Allow
Allow for this session
Always allow

Three ways to say yes. The button itself allows once; the menu beside it allows for the rest of that session without writing anything to disk, or always, which writes a durable rule into the project's own settings.

storefront
Which queue should the worker use?
1Use the existing jobs queue
2Create a dedicated checkout queue
3Ask me again after the spike test

Answer questions, not just permissions. When an agent asks you to choose, the options render as buttons, and your pick goes back verbatim in the shape the agent expects.

api-gateway 41m
Running tests · 128 passed
checkout-api api-gateway storefront dotfiles
~/checkout-api $ claude ~/api-gateway $ codex

Jump to the exact tab. Click a session and the right terminal tab comes forward - not the app, the tab - matched by the title the agent wrote for itself, so it lands correctly even when several share one directory.

checkout-api 12m 42%
Editing src/routes/checkout.ts
api-gateway 41m 88%
Running tests · 128 passed
dotfiles 2h 3m 94%
Searching for "export PATH"

Context window at a glance. A ring on every card shows how full that session's context is - amber past 70%, red past 90% - and it knows a 200k window from a 1M one, so the number is the truth rather than a guess.

Cards that show the actual request

The tool input is parsed on arrival into a typed shape: the Bash command, the Edit hunks, the Write payload, the question, the plan. A tool that cannot be rendered fully is never given an Allow button.

It nudges, then it stops

A waiting session announces for eight seconds, settles into a quiet mark, re-nudges at one, five and fifteen minutes, then goes quiet. Never while its own terminal is frontmost, you are away, or the screen is locked.

Notch or no notch

On the built-in screen it hugs the physical notch. On an external monitor it becomes a floating pill with identical geometry, so both screens look like the same machine.

Survives restarts

Sessions persist. Quit mid-run and relaunch, and the crew is still there in the right state instead of a wall of stale cards.

Native, and quiet about it

Swift and SwiftUI, no Electron, no web view. Animation pauses when the bar is covered, and a mark only redraws while its session is actually working. It is meant to run all day.

Local by construction

Everything happens on your Mac over a unix socket restricted to your user. No account, no telemetry, no network calls. Accessibility is used for one thing only - jumping to a tab - and approving never needs it.

Speaks natively to

Claude Code Codex Cursor Gemini CLI Qwen Code opencode

Any other agent CLI is detected while it runs and gets a card you can jump from. Tab-precise jumping works across every terminal we have tested, and the notch never needs to know which one you use.

Questions

Do I need a Mac with a notch?

No. On a display without one - an external monitor, or an older MacBook - Crew Tower draws a floating pill at the top centre with exactly the same geometry, so it behaves identically everywhere.

Does it send keystrokes to my terminal?

Never. There is no keystroke path in the app at all. Decisions travel back over the same local socket the agent's hook is waiting on. If a prompt has no decision channel, the only fallback offered is jumping you to the terminal.

What happens if Crew Tower is not running?

Your agents behave exactly as they did before. Every failure path in the hook exits cleanly meaning "no decision", so the terminal's own prompt stands and a session can never hang waiting on an app that is not there.

Does any of my code leave the machine?

No. There is no network layer. Crew Tower reads what your agent already writes locally and talks to it over a unix socket restricted to your user account.

Why does it want Accessibility permission?

Only to bring the correct terminal tab forward when you click a session. Approving, denying and answering need no permissions at all - decline it and everything except jumping still works.

Can I run more than one agent in the same project?

Yes, and that is the case it was built for. Sessions are identified by the title the agent writes for itself, so several agents sharing one directory stay distinguishable and jumping still lands on the right tab.