← All posts

Explainer

Why you want an always-on-top terminal for AI coding agents

To keep a terminal always on top: on Windows, flip the built-in alwaysOnTop setting in Windows Terminal; on macOS, which has no native toggle, pin the window with Hammerspoon or BetterTouchTool; or use an overlay app that ships pinned. Pinning keeps the window visible — an agent-aware overlay adds what pinning can't: a notification when the agent inside needs an answer, click-through so the window stops eating your mouse, and a daemon so the session outlives the window.

Why this matters more than it used to: an AI coding agent changed how long a "command" takes. You type a task, hit enter, and Claude Code spends the next several minutes greping, editing, and running tests on its own. You're not staring at output line by line anymore — you've moved on to your editor, a PR review, docs, maybe a build that's churning in another window. But the agent isn't truly fire-and-forget: every so often it stops to ask permission for a risky command, asks a clarifying question, or finishes and waits. The terminal needs to be one glance away, not buried under three other windows.

That's the case for an always on top terminal: a window that floats above whatever you're actually working in, so the agent's state is visible without an alt-tab. It's the same instinct that makes people pin a video call or a stopwatch on top — except here the thing you're watching does real work and occasionally needs an answer.

Why "always on top" specifically helps with agents

A normal terminal lives in your tab order. You bring it forward when you need it. That's fine when you drive every step. It breaks down when the terminal is driving itself, because the moments that matter — a yes/no prompt, a finished run — happen on the agent's schedule, not yours. If the window is behind your editor, you find out late. The agent sat idle waiting on you while you were heads-down somewhere else.

Pinning the terminal on top fixes the cheapest version of this: the agent is always in your peripheral vision. You glance, you see the cursor blinking on a prompt, you answer, you go back. It works equally well over a code editor, a browser full of docs, or a borderless-fullscreen game while a long refactor grinds in the background.

The existing ways to pin a terminal — and where they stop

Pinning a window on top is an old need, so there are tools. None of them know anything about your agent, which is the catch.

• macOS has no built-in always-on-top toggle. There's no menu item, no shortcut. People reach for Hammerspoon (a Lua snippet that sets a window's level), BetterTouchTool, or small utilities like "Afloat"/"Floaty"-style window pinners. Rectangle and other tilers move and size windows but don't pin them above others. All of these treat the terminal as a generic window — they raise it and forget about it.
• Windows Terminal has a real setting. Toggle alwaysOnTop in settings (or bind toggleAlwaysOnTop to a key) and the whole window floats. It's the cleanest native option on any OS — but it's still just a floating window. It won't tell you the agent paused.
• Quake / dropdown terminals (iTerm2's hotkey window, Guake, the Windows Terminal Quake mode) slide a terminal down over everything on a keypress. Great for a quick command, wrong shape for a long-running agent — the whole point is that it's hidden until you summon it, so you don't see state changes while it's tucked away.

Every one of these answers a different question: "keep this window on top." That's necessary but not sufficient. The window being visible doesn't mean you notice the one second the agent needs you, and a pinned terminal sitting over your editor steals the screen real estate you were using and eats your mouse clicks the moment it has focus.

What an agent-aware overlay adds on top of "on top"

The gap between a pinned terminal and a useful one is everything that depends on the overlay knowing it's running an agent, not just shell. That's the whole idea behind an AI coding agent overlay: a floating layer that understands the agent underneath it. Three things matter:

• Click-through ("ghost") mode. A floating window over your editor is a tax: it covers pixels and grabs clicks. Make it pass input through to whatever's underneath and the cost disappears — the terminal is visible but inert, your typing and clicks land in the editor or game below, and a single keypress flips it back to interactive when you want to answer.
• Notifications when the agent needs you. This is the real upgrade over any window-pinner. Instead of you watching the terminal, the terminal tells you: it flashes and chimes only when the agent hits a permission prompt, asks a question, or finishes — and otherwise stays quiet. That inverts the babysitting problem entirely, which we go into in stop babysitting your AI coding agent.
• Multiple sessions, each pinned to a folder. One agent per repo, several at once, in tabs — so you can run a refactor in one project and a bug hunt in another without juggling terminal windows. The tab that needs attention gets an accent ring so you know which one pinged.

None of the generic pinners can do this, because none of them parse what the agent is doing. A Hammerspoon snippet raises a window; it has no idea Claude Code just stopped on a PreToolUse approval. For Claude Code specifically, the events are already there to hook into — the Notification, Stop, and PreToolUse hooks fire on exactly the moments you'd want a flash — and an overlay can listen for them instead of making you watch.

Frequently asked questions

Where Backgrind fits

Backgrind is that agent-aware version: a transparent, always-on-top window on macOS and Windows that runs your real Claude Code or Cursor CLI (your login, your history) — or Grindy, our hosted model — with click-through, ambient notifications, and per-folder session tabs. A background daemon keeps the agents alive even if you close the window, so a pinged decision still reaches you while the UI is hidden. In practice it doubles as a GUI for Claude Code — the terminal is still there, but the state and decisions surface visually instead of scrolling past. If you've ever rigged Hammerspoon or alwaysOnTop to keep a terminal visible, this is the same idea with the agent's state built in. There's a simulated live demo if you want to see the flash-and-chime behavior before installing anything.