Mohano — A Real-Time Dashboard I Built Because I Wanted to See What Claude Code Was Doing

"What Are You Even Doing Right Now?"

When you set Claude Code to work on multi-agent tasks, there's one frustrating thing: the agents are working on multiple things simultaneously, but you have no idea what any of them are actually doing. Logs pour into the terminal, sure, but it's hard to see at a glance which agent is using which tool and how far along any given task is.

It feels like delegating work to several teammates, then sitting on the other side of a partition just listening to the sound of keyboards. Something is getting done — but you can't tell what.

"What are you doing right now?"

That one question was the start of the project. The name came from it too: Mohano — taken from "뭐하노" (mwo-ha-no), the Gyeongsang dialect way of asking "what are you doing?"

What I Wanted to See

What I wanted was simple: to watch the agents work with my own eyes.

I didn't want to parse terminal logs. I wanted a dashboard where, with a browser tab open, events would stream by in real time — showing what each agent was doing at any given moment, with tasks moving around like a kanban board.

Claude Code has a hooks system. You can attach shell scripts to almost any event: before and after tool calls, sub-agent start/stop, task completion. I thought I could use this to stream agent activity to an external destination.

Claude Code → hooks → send-event.sh → POST → Mohano Server → WebSocket → Browser

The hook receives event JSON on stdin, stamps a timestamp, and POSTs it to the server. The server sends it to the browser over WebSocket in real time. That's it. The architecture couldn't be simpler.

Two Days in Review

On day one, I built the server, frontend, and hook script all at once. I spun up a WebSocket server with Bun and drew the dashboard in vanilla HTML/CSS/JS. I intentionally avoided any framework. I wanted a structure with no build step — just a few files.

Parsing real Claude Code events turned out to be more complex than I expected. The fields vary by event type. But working through them one by one, the timeline view, agent view, task graph, and event log all came together. The satisfaction of seeing agent activity stream across the screen in real time for the first time was something.

On day two, I polished it so others could use it too. I made it installable with a single setup.sh command, added Docker and Render deployment support, added multi-tenant workspaces, and put up a GitHub Pages landing page.

Final count: 20 commits, 2,700 lines of frontend, 280 lines of server, 200 lines of shell scripts. One server dependency (ws), zero frontend dependencies.

Seeing It Makes It Different

When you run multi-agent tasks with the dashboard open, the experience is completely different.

Agent A reading files, Agent B running tests, and C doing research — all streaming side by side in the timeline. You can see immediately which agent is idle and which task is blocking. No need to dig through logs; you can grasp the full picture from a single screen.

This isn't just a convenience feature. If you can't see it, it's hard to trust it. The age of delegating work to AI agents is coming, but vaguely believing "it's probably doing fine" and actually being able to see what it's doing are two entirely different experiences. Observability becomes the foundation of trust in the age of automation.

What It Means to Open Source Something

Putting Mohano up on GitHub taught me something.

At first it was just a tool for myself. I built it to solve my own frustration in my own work environment. But after building it, my thinking shifted. There must be others feeling the same frustration while running multi-agent tasks with Claude Code.

The process of open sourcing something pushes the code one step further. You clean up the "only I need to understand this" hardcoding, automate the setup process, write documentation. Things you'd let slide when it's just for yourself naturally get improved when you're conscious of other users.

And most of all, the mere possibility that something you built could be useful to someone else is itself motivating. When someone actually uses it, that becomes an even more valuable experience. Issues coming in, PRs landing, use cases you never thought of emerging — that feedback loop is the appeal of open source.

The Joy of Building

Making Mohano reminded me once again. The real value of vibe coding isn't that it makes coding faster. It's that it eliminates the time spent agonizing over whether to build something at all.

In the past, I never would have dared to build a tool like this. WebSocket server, real-time dashboard, event parsing, deployment automation — each piece isn't hard on its own, but together it's too much for a "weekend project." I would have talked myself into "I can just look at the terminal logs."

But now it's different. When an idea comes to you, you can start building at that exact moment. Unfamiliar APIs aren't a problem. When you get stuck, you talk it through and get unstuck. Going from "it'd be nice to have this" to "I built this" takes two days.

And there's real joy in that process. The moment when something that only existed in your head appears on the screen. The first time you see real-time events streaming into the dashboard. When the timeline with agents moving simultaneously comes together. This is a different kind of satisfaction than just writing code fast. The feeling that you made what you wanted, with your own hands. That original joy from when you first learned to code — it comes back.