← All posts

Explainer

What is an AI coding agent overlay?

An AI coding agent overlay is a desktop always-on-top window that runs your coding agent — Claude Code, Cursor, Codex — and floats it above everything else on your screen, so you can watch the agent work and answer its prompts without switching apps. A Claude Code overlay is the same idea pointed at one agent: your real claude CLI rendered in a floating terminal you summon over your editor, a browser, your docs, or a game, and dismiss just as fast. Same agent, different container — and the container turns out to matter more than it sounds.

One disambiguation up front, because "overlay" is an overloaded word: this is not a Nix/nixpkgs overlay (that's a package-set override in the Nix language) and not a VS Code extension or editor panel. It's an ordinary desktop window with the always-on-top flag set — the agent's terminal drawn over your other apps, with nothing installed inside them.

The reason the shape exists is that autonomous agents broke the assumption every developer tool was built on: that you're sitting and watching. Let's unpack why, and what an overlay actually is.

The shape problem: agents don't fit a terminal

A terminal assumes your attention. It's a thing you sit in front of, type into, and read. That was a perfect fit when the tool only acted when you told it to. An agent doesn't work that way — you describe a task and it runs for minutes on its own, mostly without you. Suddenly the terminal is the wrong shape twice over: it demands a window you're staring at during the long stretch when there's nothing to see, and it's buried behind other apps at the exact moment it needs a yes/no.

So people improvise. A dedicated monitor for the terminal. tmux sessions and SSH. Alt-tabbing every couple of minutes "just to check." These are all workarounds for the same mismatch: the agent's interface wants to be ambient — present when you need it, invisible when you don't — and a terminal is the opposite of ambient.

What an overlay actually is

Technically, an overlay is just a normal always-on-top application window — the same category as a Discord call window, OBS, or picture-in-picture video. It draws above other windows, you can summon and hide it with a hotkey, and it renders your agent's session inside it. Crucially, it does not reach into other programs: no reading another app's memory, no injecting input, no hooking into a game. It sits over the top; the app underneath neither knows nor cares. (That distinction is the whole story for whether an overlay gets you banned — spoiler: a plain always-on-top window is in the safe category.)

A good overlay adds a few abilities on top of "on top": a glance / click-through mode where the window goes semi-transparent and your clicks pass through to whatever's underneath, and notifications so it can get your attention without staying in your face. Those two things are what make it ambient rather than just another window in the stack.

Overlay vs terminal vs IDE

All three can run an agent. The difference is the relationship to your attention:

• Terminal: a place you go to and sit in. Maximum control, zero ambience — it's either filling a window you're watching or buried where you'll miss the prompt.
• IDE (or its agent panel): great when you're actively reading every diff, but it anchors the agent inside the editor — the one app you were probably trying to step away from.
• Overlay: a layer over whatever you're already doing. You're not "in" it; it surfaces when the agent finishes or needs you, and disappears otherwise. Built for the long unattended stretch, not the heads-down review.

None of these is strictly better — they're for different moments. An overlay is the right shape precisely when the agent is meant to run while your screen is busy with something else.

Why the overlay shape fits autonomous agents

Walk through a real session and the fit is obvious. You give the agent a task and switch to something else — code in another repo, a browser, a borderless-fullscreen game. The overlay drops out of the way. The agent works. When it finishes, or hits a question, or wants to run a risky command, the overlay flashes and chimes; you glance, tap approve or type a correction, and go back. The interface is present for the two seconds that need you and absent for the ten minutes that don't.

That's also what makes overlays the natural home for the rest of the autonomous-agent toolkit: notifications instead of staring, inline approvals instead of hunting for the prompt, and several agents in tabs instead of a wall of terminals.

What it's not

Two quick clarifications, because "overlay" means different things to different people. First, this is not a game cheat or a render hack — there's no injection into another process, which is why it's a non-issue for anti-cheat (and also why it only works over borderless, not exclusive, fullscreen: exclusive fullscreen hands the whole display to one app and hides every overlay at the OS level). Second, it's not a different agent — it runs the same CLI you already use, with your login and history. The overlay is a container, not a replacement.

Frequently asked questions

Where Backgrind fits

Backgrind is an AI coding agent overlay. It wraps your own agent — Claude Code, Cursor, or our hosted Grindy model — in an always-on-top window with everything the shape implies: one hotkey to summon it and one to vanish, a click-through glance mode that lets your input pass to the app underneath, a chime only when the agent finishes or needs a decision, inline approve/deny, and tabs for running several agents at once. It floats over your editor, a browser, or a borderless-fullscreen game — no memory reading, no input injection, just a window on top.

If the terminal has always felt like the wrong place to keep a long-running agent, the overlay is the shape you were reaching for. See it in the live demo.