Why a physical AI agent monitor beats another dashboard tab

The sidebar problem

Open any modern AI coding environment — Claude Code, Cursor, Aider, Continue, Windsurf — and you'll find agent state hidden somewhere inside the app itself. A spinner in the chat panel. A tiny "thinking…" label above the input box. A collapsible "tool calls" drawer that you have to click to expand. A terminal log scrolling in the background.

All of these share the same problem: they live inside the window you're actively avoiding when the agent is working. The whole point of handing a task to an agent is that you get to do something else while it runs. So you switch to Figma, or a PR review, or Slack, or another repo. And now the agent's state is invisible.

When you need to check on it, you have to:

1. Remember the agent is running at all
2. Alt-tab back to the editor
3. Visually scan for the spinner or the tool call list
4. Try to figure out if what you're seeing is "still working" or "stuck waiting for me"
5. Alt-tab back to whatever you were actually doing

That's a lot of context switches for a UI that's supposed to save you time. And in practice, most people skip the check entirely and just come back to the editor every 10 minutes hoping the agent is done.

Peripheral vision is a superpower

Humans are exceptionally good at noticing motion and color changes in their peripheral vision — it's the evolutionary reason we can catch a ball, drive a car, and notice a snake in the grass before our conscious mind registers it. The bandwidth of peripheral attention is enormous, and crucially, it doesn't cost focus. You can be deep in a code review and still notice a bright red dot flicker on your desk.

Traditional desktop UIs deliberately waste this bandwidth. Notifications are loud and interrupting precisely because every piece of state has to fight for your center-of-screen attention. A notification badge on a taskbar icon is the best most OS designers have come up with, and even that requires you to be looking at the taskbar.

A physical device on your desk uses peripheral vision the way it's meant to be used:

• Color tells you state. A blue glow means the agent is thinking. Green means it's running a tool. Red means something broke. Yellow means it needs you. You can process this in 50 milliseconds without moving your eyes.
• Motion tells you activity. A breathing LED means "still working." A solid LED means "done and waiting." A fast flash means "urgent." Your visual cortex handles this for free.
• Stillness tells you idle. No animation, dim white LED — nothing is happening and you don't need to check.

The trust gap

There's a second, less obvious reason to move agent state onto hardware: trust asymmetry. When you give an AI agent permission to run bash or rm or git push, you're delegating capability to a system you don't fully control. The software asking for that permission is the same software that wants to run the command — it's both the actor and the gatekeeper.

Operating system designers figured this out decades ago with UAC prompts, sudo passwords, and hardware security keys. The principle is the same: there should be an air gap between "the software wants to do something" and "you said yes."

A physical button press across a piece of hardware that is not the agent is exactly that air gap. Pressing A on a physical key to approve an edit feels fundamentally different from clicking "Allow" in a popup — because it is.

What e-paper specifically gets you

I picked e-paper for InksPet deliberately. LCDs and OLEDs are fine for content you're actively looking at, but for an always-on status display that lives next to your keyboard, they have two killer downsides:

1. They glow. An always-on backlit display is a persistent distraction, especially in a dim room. Your eye keeps getting pulled back to it.
2. They draw power. An OLED pixel is never free. E-paper costs zero mW to hold an image — it only spends energy on redraws. That means an always-on display that sips about as much power as a bluetooth speaker in standby.

E-paper is also physically calm in a way that's hard to describe unless you've used one. It looks like paper. It doesn't flicker. It doesn't ask for attention. And when the pixel crab does change state, the partial refresh is subtle enough that you notice without being startled.

What we're actually building

InksPet is the concrete version of this argument: an open source firmware for the EleksCava e-paper device that turns it into a real-time AI agent monitor. It pairs with any AI coding tool that supports hooks — Claude Code, Cursor, Aider, Codex, Gemini CLI — and reflects agent state across three channels simultaneously:

• Pixel-art Clawd the crab on the e-paper display shows the current state with a unique pose for each of 12 states
• A 5-LED RGB strip shows color + animation pattern (breathing, solid, flash, fade)
• 3 hardware buttons (A / B / C) for permission approval — Allow / Always / Deny

Setup takes about 5 minutes with zero command line — you flash the firmware from your browser, the device hosts its own WiFi for provisioning, and then you paste one prompt into your AI assistant to install the hooks. The full setup guide is here.

The hardware is manufactured by EleksCava, the firmware is open source under MIT, and every release is archived on the changelog so you can always roll back.

The bigger pattern

InksPet is one small example of a pattern I think we'll see more of: physical companions for software agents. As AI assistants get more autonomous and do more work in the background, the question of "how do I know what it's doing?" will stop having satisfying software-only answers. Notifications will be more annoying. Sidebars will be more cluttered. Slack bots will be more ignored.

The interesting answer is to move status out of the screen entirely. Give agents a shape, a color, a motion, a sound — some piece of physical presence in the room. It's not a nostalgic return to "calm technology" (though it is that). It's recognizing that human attention is a limited resource, and the cheapest way to preserve it is to stop asking software to fight for it.

The pixel crab is one answer. I'm curious what others will be.