SIGNAL DESK TERMINAL APP

& MULTI-AGENT HARNESS

I'm a designer who builds. Over the last year I built an autonomous multi-agent system that runs my work around the clock — it writes code, triages my inbox, and ships pull requests while I sleep — and then designed the surface I actually use to operate it. Both halves of that sentence turned out to be hard, and the second one surprised me. Building the engine was the kind of hard I expected: architecture, constraints, a year of decisions about how a system should behave when no one is watching. But the moment it worked, a second problem appeared that I hadn't planned for. A mind that never stops is only as useful as your ability to watch it, steer it, and trust it enough to walk away. That's not an engineering problem. It's an interface problem — which means it was mine. So I designed the operator's surface three times before I got it right. Twice I reached for the familiar shapes a designer reaches for, and built them well, and abandoned them anyway. The third one is the one I keep open all day. This is the story of both: the engine, and the three attempts it took to find the right way to hold it.

[YEAR]

2025-2026

[CLIENT]

Owned Product

[TOOLS]

Figma, Claude Design

Codex, Pencil &

Claude Code

1.0

SIGNAL DESK APPLICATION

& MULTI-AGENT HARNESS

I'm a designer who builds. Over the last year I built an autonomous multi-agent system that runs my work around the clock — it writes code, triages my inbox, and ships pull requests while I sleep — and then designed the surface I actually use to operate it. Building the engine was hard in the way I expected. But the moment it worked, a second problem appeared: a mind that never stops is only as useful as your ability to watch it, steer it, and trust it enough to walk away. That's not an engineering problem. It's an interface problem — which means it was mine. I designed the operator's surface three times before I got it right.

[YEAR]

2025-2026

[CLIENT]

Own Product

[TOOLS]

Figma, Claude Design

Codex, Pencil &

Claude Code

I built the engine. Then I built the cockpit to fly it. Two hard problems — and the second one only exists because the first SUCCEEDED. THIS PRODUCT CASE STUDY DEMONSTRATES MY WORK BUILDING A CUSTOM MULTI-AGENT HARNESS AND SIGNAL DESK, A TERAX AI APP FORK I BUILT TO CONTROL IT.

[THE CHALLENGE]

A 24/7 agent system is easy to start and hard to live with. Once you have agents writing code, triaging your inbox, and shipping pull requests while you sleep, the real problem isn't capability — it's control. How do you watch a mind that never stops? How do you step in mid-thought without breaking its flow? How do you trust it enough to walk away, and stay close enough to pull it back with one word? I tried to answer that question three times. Twice as a designer reaching for the familiar shapes — a web dashboard, a desktop app. Once, finally, as a power user who lives in the terminal. The first two were well-built and wrong. The third is the one I keep open all day. This case study is about the engine that made the question urgent, and the interface that finally answered it.

[THE CHALLENGE]

A 24/7 agent system is easy to start and hard to live with. Once you have agents writing code, triaging your inbox, and shipping pull requests while you sleep, the real problem isn't capability — it's control. How do you watch a mind that never stops? How do you step in mid-thought without breaking its flow? How do you trust it enough to walk away, and stay close enough to pull it back with one word? I tried to answer that question three times. Twice as a designer reaching for the familiar shapes — a web dashboard, a desktop app. Once, finally, as a power user who lives in the terminal. The first two were well-built and wrong. The third is the one I keep open all day. This case study is about the engine that made the question urgent, and the interface that finally answered it.

  1. SIGNAL DESK - A TERAX AI FORK

[BUILDING THE AGENT OPERATOR BOARD]

A pilot doesn't watch the engine through a porthole. They have a cockpit — every critical instrument in one glance, every control under their hands, no walking back to the engine room to check a gauge. That's what SignalDesk is: a cockpit for a system of agents. I built it by forking Terax, an open-source, terminal-first AI development workspace (Tauri 2, Rust, React, xterm.js). Terax was already the right substrate — fast, native, terminal-native, the place I actually work. What it didn't have was a way to see across agents. So I added one: the Agent Operator Board, an overlay that sits on top of the terminal and turns a wall of separate processes into a single, legible roster you can watch and drive. The board groups every agent by what it needs from me right now — Attention, Working, Calm, Inactive — so the question "where should I be looking?" answers itself before I ask it. Underneath, an event-streaming architecture (a local hub, a bridge per machine, server-sent events) keeps the picture live without polling. And because not every harness can do every thing, each agent advertises its own capabilities — can it take text input, stream voice, report usage? — and the interface lights up only the controls that agent actually supports. One surface, many kinds of agent, no broken buttons.

[STEP-BY-STEP]

An interactive walkthrough from config detection to final setup.

[MULTI-MODEL]

Keys for multiple providers, because multi-agent orchestration meant routing across models, not betting on one.

[BUILDING THE AGENT OPERATOR BOARD]

A pilot doesn't watch the engine through a porthole. They have a cockpit — every critical instrument in one glance, every control under their hands, no walking back to the engine room to check a gauge. That's what SignalDesk is: a cockpit for a system of agents. I built it by forking Terax, an open-source, terminal-first AI development workspace (Tauri 2, Rust, React, xterm.js). Terax was already the right substrate — fast, native, terminal-native, the place I actually work. What it didn't have was a way to see across agents. So I added one: the Agent Operator Board, an overlay that sits on top of the terminal and turns a wall of separate processes into a single, legible roster you can watch and drive. The board groups every agent by what it needs from me right now — Attention, Working, Calm, Inactive — so the question "where should I be looking?" answers itself before I ask it. Underneath, an event-streaming architecture (a local hub, a bridge per machine, server-sent events) keeps the picture live without polling. And because not every harness can do every thing, each agent advertises its own capabilities — can it take text input, stream voice, report usage? — and the interface lights up only the controls that agent actually supports. One surface, many kinds of agent, no broken buttons.

[TELEMTRY]

The honest readout of what a connection can and can't do. It makes capability negotiation visible: instead of guessing why a control is greyed out, you see which signal is missing.

[ACTIVITY FEED]

Recent history as a timeline — status, messages, commands, approvals, errors. How you reconstruct "what just happened" without scrolling the whole conversation.

[TERAX AI AGENT PROFILES]

I also themed Terax itself — the open-source app underneath, and the real star from an application standpoint. This screen is my theme on its profile builder, where you compose the agents that run inside the app.

[ACTIVITY FEED]

Recent history as a timeline — status, messages, commands, approvals, errors. How you reconstruct "what just happened" without scrolling the whole conversation.

[BUILDING THE AGENT OPERATOR BOARD]

A pilot doesn't watch the engine through a porthole. They have a cockpit — every critical instrument in one glance, every control under their hands, no walking back to the engine room to check a gauge. That's what SignalDesk is: a cockpit for a system of agents. I built it by forking Terax, an open-source, terminal-first AI development workspace (Tauri 2, Rust, React, xterm.js). Terax was already the right substrate — fast, native, terminal-native, the place I actually work. What it didn't have was a way to see across agents. So I added one: the Agent Operator Board, an overlay that sits on top of the terminal and turns a wall of separate processes into a single, legible roster you can watch and drive. The board groups every agent by what it needs from me right now — Attention, Working, Calm, Inactive — so the question "where should I be looking?" answers itself before I ask it. Underneath, an event-streaming architecture (a local hub, a bridge per machine, server-sent events) keeps the picture live without polling. And because not every harness can do every thing, each agent advertises its own capabilities — can it take text input, stream voice, report usage? — and the interface lights up only the controls that agent actually supports. One surface, many kinds of agent, no broken buttons.

[TELEMTRY]

The honest readout of what a connection can and can't do. It makes capability negotiation visible: instead of guessing why a control is greyed out, you see which signal is missing.

[ACTIVITY FEED]

Recent history as a timeline — status, messages, commands, approvals, errors. How you reconstruct "what just happened" without scrolling the whole conversation.

[TELEMTRY]

The honest readout of what a connection can and can't do. It makes capability negotiation visible: instead of guessing why a control is greyed out, you see which signal is missing.

[BUILDING THE AGENT OPERATOR BOARD]

A pilot doesn't watch the engine through a porthole. They have a cockpit — every critical instrument in one glance, every control under their hands, no walking back to the engine room to check a gauge. That's what SignalDesk is: a cockpit for a system of agents. I built it by forking Terax, an open-source, terminal-first AI development workspace (Tauri 2, Rust, React, xterm.js). Terax was already the right substrate — fast, native, terminal-native, the place I actually work. What it didn't have was a way to see across agents. So I added one: the Agent Operator Board, an overlay that sits on top of the terminal and turns a wall of separate processes into a single, legible roster you can watch and drive. The board groups every agent by what it needs from me right now — Attention, Working, Calm, Inactive — so the question "where should I be looking?" answers itself before I ask it. Underneath, an event-streaming architecture (a local hub, a bridge per machine, server-sent events) keeps the picture live without polling. And because not every harness can do every thing, each agent advertises its own capabilities — can it take text input, stream voice, report usage? — and the interface lights up only the controls that agent actually supports. One surface, many kinds of agent, no broken buttons.

[TELEMTRY]

The honest readout of what a connection can and can't do. It makes capability negotiation visible: instead of guessing why a control is greyed out, you see which signal is missing.

[ACTIVITY FEED]

Recent history as a timeline — status, messages, commands, approvals, errors. How you reconstruct "what just happened" without scrolling the whole conversation.

[TELEMTRY]

The honest readout of what a connection can and can't do. It makes capability negotiation visible: instead of guessing why a control is greyed out, you see which signal is missing.

5. OUTRO

[WHERE DO I GO FROM HERE…]

I set out to build an autonomous partner and discovered, somewhere in the middle, that I was really building two things at once: a system powerful enough to be worth operating, and the operator's surface that makes that power usable by a single human. The engine and the cockpit. You can't design one well without deeply understanding the other — and that, more than any individual screen, is what this project taught me.


The detours mattered. Bumba Desktop and Bumba Controller weren't failures so much as the cost of finding out what shape the answer actually had. A desktop app made the agent a place I visited. A web dashboard made me an observer of work I needed to be inside of. Both were well-built; both were wrong; and killing them is what made SignalDesk obvious. The willingness to throw away good work when it doesn't fit the user is, I think, the most underrated skill in design.

As agents get more capable, intelligence stops being the scarce thing. The scarce thing becomes one person's ability to direct a great deal of it without losing the thread. That's not an engineering problem. It's a design problem — and it's the one I intend to keep solving OVER TIME.

Where it nets out: an engine that runs 24/7 and stops on one word, a cockpit I keep open all day, and a concept — Dreamcatcher — that points at where this goes next. Because the through-line of all of it is the same conviction. As agents get more capable, the scarce thing won't be intelligence. It'll be the ability of one person to direct a great deal of it without losing the thread — to see what it's doing, trust it enough to walk away, and stay close enough to pull it back. That's an interface problem. It's a design problem. And it's the one I intend to keep solving.

NEXT PROJECT

BUMBA MODULAR FRAMEWORK

A RESEARCH PROJECT

I built AN engine. Then I built the cockpit to fly it. Both CHALLENGES taught me that building AN AGENT SYSTEM and operating it are two different problems.

[THE CHALLENGE]

A 24/7 agent system is easy to start and hard to live with. Once agents are shipping PRs while you sleep, the real problem isn't capability — it's control: how do you watch a mind that never stops, and trust it enough to walk away while staying close enough to pull it back with one word? I tried to answer that three times. Twice as a designer reaching for familiar shapes — a web dashboard, a desktop app. Once, finally, as a power user who lives in the terminal. The first two were well-built and wrong. The third is the one I keep open all day.

  1. MULTI-AGENT HARNESS

Loading repository...
Loading repository...

This is not my complete final harness build, but this will give you a working harness and a leaping head start at building your own:

[BRINGING MY DREAM TO LIFE]

I wanted an executive-level partner that works while I don't — a system that wakes up, reads my calendar, clears my inbox, picks up engineering work off a queue, and is still there in the morning with PRs to review. The obvious way to build it is wrong. The industry reflex is a swarm of agents talking to each other — a committee of bots negotiating in a shared channel. I built the opposite. Bumba is one mind with very good tools: the main agent is the brain, everything else is a tool it picks up and sets down. Specialists never talk to each other; the call tree stays flat, caller → callee → return, with zero coordination overhead. It's the decision that runs against every popular multi-agent pattern, and it's the one that makes the system feel like a single capable operator instead of a noisy room. And the org chart isn't a diagram — it's enforced in code. Every department result passes through deterministic gates before it returns, including a Delegation Floor that won't let a chief claim a team's work and do it solo. A single halt policy means one word stops everything and cancels in-flight work. The behaviors are mechanical, which means they're real. When work maps to a specialty, the main agent calls a department — Strategy, Design, QA, Operations, Job Search — built fresh, run, torn down. A separate Board of Directors convenes only for genuinely strategic calls. The departments build; the Board decides. The engine works. It runs continuously, recovers from crashes, ships real code, and stops on command. But an engine you can't feel is one you don't trust — and for most of this year, the only way to feel it was to read logs.

I'd built a mind that never sleeps — and the only way to watch it was to read its logs. The engine was done. The hard design problem was just beginning.

  1. SIGNAL DESK - A TERAX AI FORK

Loading repository...

[BUILDING THE AGENT OPERATOR BOARD]

A pilot doesn't watch the engine through a porthole. They have a cockpit — every instrument in one glance, every control under their hands. That's what SignalDesk is: a cockpit for a system of agents. I built it by forking Terax, an open-source, terminal-first AI workspace — already the right substrate, the place I actually work. What it lacked was a way to see across agents, so I added the Agent Operator Board: an overlay that turns a wall of separate processes into a single legible roster, grouped by what each agent needs from me right now — Attention, Working, Calm, Inactive — so "where should I be looking?" answers itself before I ask. I don't run one agent system, I run several — my Bumba harness, a web agent, the coding agents Terax detects in its own panes. The Operator Board is the one place they all report to: select any agent and get the same cockpit — overview, a conversation lane where watching becomes intervening, telemetry, an activity feed — regardless of what's under the hood.

[SIGNAL DESK WALKTHROUGH]

  1. DESIGN SYSTEM AND EXPERIMENTS

[BUILDING THE DESIGN SYSTEM]

I didn't abandon Bumba Controller because it was broken. I abandoned it because no amount of polish fixes a form factor that mismatches how the operator thinks. That was the second half of the lesson — and it's the one that pointed straight at the terminal. Across all three attempts, the visual language stayed coherent because I treated the design system as the constant and the form factor as the variable. Working with Claude as a design partner, I built the system as tokens first — palette, type, spacing, elevation expressed as variables — so a theme could move from a web dashboard to a desktop shell to a terminal overlay without being rebuilt. Restrained, near-monochrome, editorial. Almost no shadow. The discipline that let me throw away two interfaces without throwing away the look is the same discipline that made the third one feel inevitable when it arrived.

[DESIGN SYSTEM WITH CLAUDE DESIGN]

  1. DREAMCATCHER APP CONCEPT

Loading repository...

[NODE BASED CHAT INTERFACE]

One more interface, the most speculative — a concept I prototyped to answer a different question: not "how do I operate my agents," but "how do I think with one without losing the thread." Every chat with an AI is linear. You go down a path, it fails, you scroll back — and the structure of your thinking collapses into one flat transcript. Dreamcatcher makes the conversation a graph, not a list: a living map of nodes where every message is a place you can stand, branch from, and return to. Dead-end a path and the branch dims but never disappears. The part I'm proudest of is Education Mode — select any node and ask it to explain simply, go deeper, or find the flaw. Most chat interfaces are built to agree with you; this one is built to stress-test your thinking. A knowledge garden instead of a graveyard of closed tabs.

[DREAMCATCHER WALKTHROUGH]

5. OUTRO

[WHERE DO I GO FROM HERE…]

I set out to build an autonomous partner and discovered I was building two things at once: a system powerful enough to be worth operating, and the operator's surface that makes that power usable by a single human. The engine and the cockpit. You can't design one well without deeply understanding the other. The detours mattered. Bumba Desktop and Bumba Controller weren't failures so much as the cost of finding out what shape the answer had — both well-built, both wrong, and killing them is what made SignalDesk obvious. The willingness to throw away good work when it doesn't fit the user is the most underrated skill in design.

As agents get more capable, intelligence stops being the scarce thing. The scarce thing becomes one person's ability to direct a great deal of it without losing the thread. That's not an engineering problem. It's a design problem — and it's the one I intend to keep solving.

Where it nets out: an engine that runs 24/7 and stops on one word, a cockpit I keep open all day, and a concept that points at where this goes next.

NEXT