I Ditched My AI Agent Dashboard for Obsidian

I spent a few days building a React dashboard. Dark mode, real-time updates, graphs showing agent activity across my network. My agents helped me build it. It looked incredible. I showed it to a friend and they said "wow, that's impressive." Then I deleted the entire repository.

Something felt wrong. I couldn't put my finger on it at first. But the more I worked with it, the more I realized I was solving the wrong problem. I was building a UI that will probably be obsolete at some point. With the ultra-fast evolution of OpenClaw, it's another app I would have to maintain.

The Dashboard Trap

The idea seemed smart. I have multiple AI agents running on different machines. They need coordination. They need to share state. They need to report what they're doing. What better solution than a beautiful dashboard?

So I built one. WebSocket connections. Agent status indicators. Task queues visualized with drag-and-drop. I even added a dark mode toggle because of course I did.

Then came the maintenance. One agent would fail to report and I'd spend an hour not knowing it had failed silently. The dashboard itself became a project that needed its own dashboard.

It hit me during a weekend when I wanted to check on my agents but couldn't because the server was down. I was locked out of my own system because the UI layer failed. That's when I realized: I had built a cage for myself.

The Problem

If you look around. Everyone building AI agents is also building some sort of complex UIs to coordinate them. We have agent frameworks with admin panels. Status dashboards with graphs and charts. It's beautiful, but is it necessary?

Agents are programs. They can read files. They can write files. They don't need a "dashboard." They need data. The dashboard is for us. And we already have tools to read and write data.

The problem isn't coordination. It's that we're over-engineering the coordination layer because that's what we're used to doing.

The "Dumb" Solution

I deleted the React dashboard.

Then I opened Obsidian.

I created a folder called 07-agents/ in my vault. Each agent got its own subfolder with three files: SOUL.md (its personality and purpose), a kanban-style task list, and a reports/ folder.

That's it. No UI. No database. Just markdown files in a folder structure.

I updated AGENTS.md and created a skill to ensure that the agents knew what, how and where to create files.

How It Actually Works

My setup is intentionally simple:

• Separated Linux server with OpenClaw (on a small NUC)
• Mac with Obsidian: I work on my laptop. This is where I read reports, assign tasks, and review what the agents are doing.
• rsyncover Tailscale: every 5 minutes, a cron job syncs the 07-agents/ folder between my server and my laptop using rsync over SSH through Tailscale. No complex sync engine. Just a command that runs in the background.
• Agents read/write markdown files: when an agent needs to report something, it appends to a markdown file. When it needs a new task, it reads its task list. Just file I/O.

Jarvis, my main agent ensures every X mins, that the agents know they have a folder of files to work with and they successfully do their tasks.

The Setup

I use the PARA method for my Obsidian vault, so agents live in their own corner: 07-agents/. Each agent has a consistent structure:

• SOUL.md. The agent's personality, capabilities, and boundaries. This is their definition file.
• Task List.md. A kanban board in markdown. Backlog, In Progress, Review, Done.
• reports/. A folder where the agent dumps its daily reports, findings, and outputs.
• knowledge/. Reference material the agent needs to do its job.

I use Dataview to create dashboards. A simple query gives me a view of all in-progress tasks across all agents. Another query shows me recent reports. It's not real-time in the web dashboard sense, but it's real enough. I refresh when I want updates.

Real Benefits

This setup has advantages I didn't anticipate:

1. Offline capable: I can work on my laptop without internet. The agents keep running. When I reconnect, rsync catches up. No sync conflicts, no "you have unsaved changes" warnings.
2. Plain text = future proof: markdown isn't going anywhere. Even if Obsidian disappeared tomorrow, I'd still have readable files.
3. No UI maintenance: I don't maintain a UI anymore. The UI is Obsidian, which someone else maintains. I just write markdown.
4. Portable: I can access agent data from any device that reads text files. My phone. A tablet. A borrowed computer. No authentication flow required.
5. Git-friendly: the entire coordination layer can be version controlled. I can see exactly what an agent did yesterday by looking at git history.

Technical Deep Dive

For those who want to try this, here's the actual setup:

The rsync command is simpler than you'd expect:

rsync -avz --delete --exclude='.git' \
  -e "ssh -i ~/.ssh/agent_sync" \
  ~/obsidian/07-agents/ \
  server:/home/agents/vault/

(I confess that my agent did the whole setup...) 😬

I run this every 5 minutes via cron. The --exclude='.git' is important. I learned that the hard way when git corruption caused sync issues.

Conflict resolution is simple: newer wins. rsync handles this. If I edit a task on my laptop while an agent updates its status, whichever finishes last persists. In practice, this almost never causes problems because agents mostly append to files, and I mostly edit task lists.

Health monitoring comes through Telegram. Each agent sends me a daily message: tasks completed, any blockers, and a status emoji. If I don't get the message, something's wrong. It's lo-fi, but it works.

The key insight: Agents don't need to know about each other. They just need to know about files. If Agent A writes a report that Agent B needs to read, that's just filesystem permissions. No message bus required.

Why This Wins

I spent a few days building complexity with agent help and two hours replacing it with simplicity. The simple solution works better.

The dashboard I built was impressive. It was also unnecessary. Agents don't need dashboards. They need data. Humans don't need real-time graphs. We need context.

Markdown files in a synced folder give both groups exactly what they need. Agents get structured data they can parse. Humans get readable documents they can understand. No translation layer required.

The best part? When something breaks, I can debug it with cat and grep. I don't need to check server logs and database connections. I just look at the files.

Sometimes the dumb solution is the smart one.

What would you simplify in your setup if you weren't afraid of looking unsophisticated?