The LED Status Paradigm

You've delegated a task to an AI agent. It's running in a terminal somewhere. How do you know what it's doing?

The traditional answer: watch the output scroll by. Read the logs. Check back periodically.

This doesn't scale. If you have three agents running, you can't watch three terminals simultaneously. You end up context-switching constantly—glancing at one window, then another, losing focus on your actual work.

I spent a week building Rithm's LED status system. Here's why.

The Hardware Metaphor

Every hardware device uses LEDs to communicate state. Your laptop has a power LED, maybe a charging indicator. Your router has lights for power, network, and activity. Hard drives blink when they're reading or writing.

These indicators share a property: they require zero cognitive load to interpret. You don't read them. You perceive them. The difference between "blinking" and "solid" registers before conscious thought.

This is the paradigm shift I wanted for agent management. Not "read the terminal output" but "glance at the indicator."

Five States, Five Colors

Rithm's LED system has five states:

Gray (idle): Nothing happening. The task exists, but no agent is working on it. Maybe it's waiting to be started. Maybe the previous run finished.

Purple, pulsing (working): The agent is actively doing something. Thinking, executing code, reading files. This is the "I'm on it" signal.

Amber, pulsing (clarification): The agent has a question. It needs information from you before it can continue. Maybe it's asking which approach to take. Maybe it needs access credentials.

Red, pulsing (permission): The agent wants to do something potentially impactful—delete files, make API calls, run destructive commands—and needs your explicit approval.

Green, solid (complete): The agent finished its work. The task is ready for your review. Time to look at what it produced.

Five states. Five colors. A tiny vocabulary that covers the critical information: Is it working? Does it need me? Is it done?

The Technical Implementation

The obvious approach—parsing terminal output for keywords—is fragile. Agents output different things. Success messages vary. Error formats change.

Instead, Rithm monitors the process tree. When an agent runs in a terminal, it spawns child processes: the language model call, the tools it invokes, the commands it executes. The Rust backend uses the sysinfo crate to inspect this tree.

• Shell with no children = idle
• Agent process running with no grandchildren = thinking (LLM call)
• Agent process with grandchildren = executing (running tools)

This is more reliable than text matching because it observes behavior, not output.

For richer state detection—particularly the "waiting for permission" state—Rithm integrates with OpenTelemetry. Some agents emit structured telemetry that reveals their internal state. When available, we use it. When not, we fall back to process inspection.

There's also a decay mechanism. If an agent was "thinking" but we haven't seen activity in 3 seconds, we fade back to idle. This prevents stuck indicators when something goes wrong silently.

The Attention Economy of Agent Management

Here's the core insight: human attention is finite. Every context switch has a cost. Every "let me check on that terminal" interrupts flow.

Chat interfaces are high-bandwidth, high-attention. You're actively engaged—reading, responding, following the thread. That's appropriate for some interactions but exhausting when scaled to multiple parallel agents.

LEDs are low-bandwidth, ambient. They communicate state without demanding focus. You can work on something else entirely and still know, peripherally, that your three agents are purple-purple-green: two working, one done.

This maps to how managers work in organizations. You don't hover over every employee. You have status meetings, dashboards, signals that tell you where attention is needed. LEDs are that dashboard for agents.

What This Enables

With reliable status indicators, new workflows become possible:

Parallel delegation: Start five tasks, glance at the LED column, focus on the one that needs you. The others will signal when they're ready.

Interruptible work: You can step away. When you come back, a quick scan of the LEDs tells you exactly what happened. No need to scroll through five terminal histories.

Priority by state: Red indicators need immediate attention—something wants permission. Amber is next—something has a question. Purple can wait—it's making progress. Gray and green can wait longest—they're not actively blocked.

The LED becomes a triage mechanism.

The Broader Pattern

As AI agents become more autonomous—running for minutes or hours, making decisions, completing multi-step plans—status communication becomes a first-class design problem.

I think we'll see more tools adopt this paradigm. Not necessarily LEDs specifically, but glanceable, ambient status indicators that don't demand active attention.

The alternative is a return to the mainframe era: submitting jobs, waiting, checking back. That's technically functional but misses the opportunity for fluid human-agent collaboration.

The best status indicator is one you don't have to read. It just tells you.

The Takeaway

Building the LED system took longer than I expected—about a week of the 10-day development cycle. Was it worth it?

Yes. Because it changed how I use the app.

Before LEDs, I'd constantly switch to terminals to check progress. After, I keep the task list visible in one corner and work on other things. The LEDs catch my peripheral vision when something changes.

It's a small thing. A colored dot. But it's the difference between managing agents as a constant active task versus having ambient awareness of parallel work.

In attention terms, that's enormous.