The Single Pane of Glass.

Five agents · one inbox

The problem

If you run more than one AI coding agent, you already know the failure mode. Claude Code pings from the desktop. Codex pings from a different window. Cursor has its own private idea of "done." A cloud agent finished something an hour ago and never told you, because it had no way to.

Your attention becomes the router. That is the tell: the most expensive router you own is being paid to do the least interesting job in the system.

Five inboxes for five agents is not a workflow. It's a part-time job you didn't apply for.

What it is

A single pane of glass is an AI agent orchestration workflow: one screen and one interrupt channel that shows every AI coding agent you run, which are working, which are idle, which are blocked on you, so you can manage multiple AI coding agents without opening five separate apps to find out what each one is doing.

It doesn't replace your tools. It wraps them. Claude Code and Codex still run exactly as they did yesterday; only what happens to their notifications changes. That distinction matters for anyone comparing AI developer productivity tools, because it means adopting this costs you nothing in capability and only gains you a channel.

The four planes

Name the layers and the fog clears. A fleet of agents worth running has exactly four planes, and only the first one is yours to operate personally, twice a day, on purpose.

The stack: five tools, one job each

The elegant part of this setup is that nothing in it is exotic. Five well-worn tools, each doing exactly one job, wired together in an afternoon.

And the agents themselves, Claude, Codex, Cursor, OpenRouter, z.ai, all funnel into that same inbox instead of each claiming its own corner of your attention. Supervise your existing harnesses; don't replace them.

Claude Code vs. Codex vs. Cursor vs. Happy

These four get compared constantly, but they're not competing for the same job. Here's the honest breakdown of what each one is actually for inside a single-pane-of-glass setup.

How sessions actually flow

The one finding everyone who has built this agrees on: state lives server-side in tmux, and every phone, tablet and laptop is a reconnecting viewer. Once that clicks, the 30-second reconnect tax and the chat that died mid-dog-walk turn out to be the same bug, session state sitting in the wrong place.

1. Stand up the boxA small Hetzner VPS, joined to your Tailscale network. This becomes the one host that never sleeps.
2. Create named lanesOne persistent tmux session per workstream. Nothing lives on a single laptop again.
3. Wrap your agents in HappyClaude and Codex run inside those tmux sessions, under Happy, so the whole fleet shows up in one list.
4. Attach from anywhereTermius or Blink, over Tailscale, from Mac, iPad and iPhone. Every device is a viewer now, never an owner: the same hand-off discipline that makes switching devices mid-task painless.
5. Normalize the alertsHooks and events write one line (lane, reason, age) into a single inbox. Mute everything else.

# create a persistent lane on the VPS
$ tmux new -A -s build

# wrap the real CLI so it joins the fleet list
$ happy claude

# attach from any device, over Tailscale
$ ssh build-vps
# ...or open the same host in Termius / Blink

Watch it in action

Here is the loop, simulated. Five agents post a one-line ping each; the inbox collapses them into a single digest and tells you exactly which one, if any, actually needs you.

What you need to run it

Four pieces, and the whole thing is standing by evening.

What actually broke, before this

Before any of this, closing the laptop lid was an event. Even with Claude's own remote-connect option, a session away from the machine was unstable at best, more often, it just wasn't there anymore.

It wasn't only a device problem. The same agent, running the same task, behaved wildly differently depending on where it ran:

The cloud runners were the worst of it. Environment settings were restrictive enough that most tools simply failed to authenticate. Then a disconnect. Then a cold repo had to spin up from nothing, which was slow before anything had even started. Merging back was its own fight. A lot of the workflows just didn't work, full stop.

Twenty or thirty different "flavors" of the same job (desktop app, terminal, Mac, VPS, cloud) each with its own config, its own tools, its own process. Mind-blowing complexity just to keep track of where you even were.

Now there's one place. Sessions don't die. Lose the connection, close the laptop, put down the iPad, pick up the phone, it's sitting right there, exactly where you left it, the next time you open anything up.

Inside the inbox

One digest entry looks like this in practice. This is an illustrative example, but the format is exact: lane, reason, age, and whether it earned a push:

What it's not

• It doesn't replace Claude Code, Codex or Cursor. It wraps the CLIs you already trust.
• It doesn't act on your behalf. It surfaces what needs a decision; you still make the call.
• It isn't a vendor's dashboard product. It's five tools you already know, wired together, that you fully own.

When to skip it

If you run exactly one agent, on one device, and you're always at your desk when it needs you, skip this. The setup earns its keep once you're supervising more sessions than you can hold in your head, or once you've lost work because a laptop went to sleep at the wrong moment.

A readiness checklist

Why it works

None of this is a fad. It rests on a few well-established ideas about how attention actually behaves.

• Attention residue. Switching between tasks leaves part of your attention on the one you just left, degrading performance on the next one: a finding formalized by Sophie Leroy in “Why is it so hard to do my work?” (Organizational Behavior and Human Decision Processes, 2009). Five separate agent apps are five sources of residue, all day.
• Alert fatigue. Widely documented in clinical alarm management and on-call engineering: when everything pages you, you stop trusting any of it, and real emergencies get the same shrug as noise. A single, disciplined severity tier is the standard countermeasure.
• One source of truth beats many partial ones. Standard observability practice in operations teams: consolidating monitoring into a single pane consistently shortens the time it takes to notice and act on the thing that matters.

FAQ