Build a real-time local AI monitoring dashboard with OpenClaw using JSONL session parsing, Server-Sent Events, gateway status telemetry, and live session streaming. Learn how costica-dashv6 transforms raw local AI logs into a production-grade observability system.
OpenClaw stores session activity as structured logs.
These logs include:
By default, they live inside:
~/.openclaw/agents/main/sessions/Each session is stored as JSONL.
That means every line is an independent JSON object representing an event in the agent lifecycle.
Example:
{
"type": "tool_call",
"tool": "exec",
"timestamp": "2026-06-01T14:10:22Z"
}This is gold.
It means OpenClaw already exposes everything needed for live observability.
You just need to stream it.
---
The dashboard follows a lightweight local-first architecture.
OpenClaw Session Logs
↓
JSONL Parser
↓
SSE Stream Server
↓
Dashboard Frontend
↓
Live VisualizationThe goal:
zero cloud dependencies.Everything runs locally.
No external telemetry platform.
No third-party monitoring service.
No SaaS lock-in.
---
The first challenge was reading active session files in real time.
OpenClaw appends events continuously.
That means traditional file reads are useless.
Instead, the parser tails the latest session log.
Example approach:
const fs = require("fs");
fs.watch(sessionDir, (eventType, filename) => {
if (filename.endsWith(".jsonl")) {
streamLatestLines(filename);
}
});Each line gets parsed individually:
const event = JSON.parse(line);From there, events are normalized into dashboard-friendly structures.
For example:
{
"type": "tool_call",
"tool": "read_file"
}{
"type": "reasoning"
}{
"type": "error"
}This becomes the live activity feed.
---
For real-time updates, I chose SSE over WebSockets.
Why?
Because dashboard traffic is one-directional.
The server pushes.
The frontend listens.
Perfect SSE use case.
Backend stream:
res.write(`data: ${JSON.stringify(payload)}\n\n`);Frontend listener:
const source = new EventSource("/api/stream");
source.onmessage = (event) => {
const data = JSON.parse(event.data);
};Benefits:
This powers live updates without polling.
---
Session logs show what the agent does.
Gateway telemetry shows whether the system is alive.
The dashboard polls:
openclaw status --jsonThis exposes critical runtime state:
The dashboard refreshes gateway state continuously.
This gives instant visibility into:
For local AI infrastructure, this is essential.
---
The dashboard is split into multiple streams.
Shows:
---
Displays:
---
Tracks:
This matters because local AI failures are often infrastructure failures first.
Not model failures.
---
This is the most useful panel.
It renders the latest assistant activity in real time with streaming text output.
You can literally watch OpenClaw think.
When debugging workflows, this changes everything.
---
Most AI observability platforms assume cloud inference.
They focus on:
Local AI needs different metrics.
You care about:
That’s what costica-dashv6 solves.
It treats local AI like real infrastructure.
Because it is.
---
This setup is incredibly useful for:
See exactly where execution stopped.
---
Track command execution flow.
---
Spot token pressure before session collapse.
---
Catch gateway problems instantly.
---
Running local AI isn't just about inference.
It’s about system visibility.
Once your stack includes:
you need observability.
A real-time dashboard turns OpenClaw from a black box into an inspectable system.
And that’s the difference between experimenting with local AI…
and actually operating it.
---
Building costica-dashv6 proved something important:
OpenClaw already exposes everything needed for serious local AI monitoring.
The session JSONL architecture makes real-time introspection possible.
Add:
…and you get a production-grade local AI observability layer.
If you’re serious about local agents, build the dashboard.
Because once you can see the system thinking, debugging becomes engineering instead of guessing.