Claude Code Multi-Agent Observability System
Real-time monitoring for Claude Code agents through simple hook event tracking.
Evidence: README describes security features (blocking rm -rf, sensitive file access) but lacks implementation details; hook scripts send event data to a local server, but data retention and access control are not specified; dependencies are not pinned, posing supply chain risk; no user confirmation mechanism mentioned; external effects include starting a server and sending HTTP requests, but no rollback plan; publisher identity unverified. Deductions: least privilege only partially implemented (documented blocking of dangerous commands), user confirmation absent, data flow transparency insufficient, sensitive data handling unclear, dependency security unaddressed, external effects not fully explained, rollback missing, source attribution not provided.
Evidence: README and project structure are consistent, hook script naming is clear, but no test results or error handling details provided; dependencies (Bun, uv, just) are not pinned, availability depends on external factors; failure messages not documented. Deductions: self-consistency is adequate, but dependency availability not guaranteed, failure messages not provided.
Evidence: README targets developers, provides multiple usage scenarios (single project, multi-project, team orchestration), but capability boundaries not explicit (e.g., supported Claude Code versions); trigger precision controlled via matcher and event types, but specific trigger conditions for all events not explained; environment fit depends on specific toolchain (Bun, uv), other environments not addressed. Deductions: audience and scenarios well covered, but capability boundaries unclear, environment fit limited.
Evidence: README has clear structure, includes installation steps, project structure, configuration; provides examples and FAQ (via video links); but no known limitations, license, version changelog; maintenance responsibility not clear (publisher unverified). Deductions: information architecture and install notes good, but naming stability not guaranteed (no version numbers), examples and FAQ partially rely on external videos, known limitations missing, license missing, versioning changelog missing, maintenance responsibility unclear.
Evidence: Output is a real-time dashboard with filtering, charts, etc., good usability; marginal value lies in multi-agent observability, but not compared with other tools; cost-benefit not quantified, depends on multiple external services (API keys). Deductions: output usability good, but marginal value not fully argued, cost-benefit not assessed.
Evidence: Claims in README (e.g., security features) lack code-level evidence; no independent verification sources; facts and inferences mixed (e.g., marketing language like 'vibe coding'). Deductions: claim traceability insufficient, cross-source corroboration missing, fact-inference separation unclear.
- Dependencies are not pinned, posing supply chain risk.
- No license information provided, use with caution.
- Hook scripts send event data to a local server, but data retention and access control are not specified.
- Publisher identity unverified, maintenance responsibility unclear.
What does this agent do, and when should you use it?
This is an open-source real-time monitoring system for tracking Claude Code agent behavior. It captures all tool calls, task handoffs, and agent lifecycle events via the hook system, sends them via HTTP POST to a Bun server, stores them in SQLite, and streams them in real-time to a Vue 3 client via WebSocket. The system supports concurrent monitoring of multiple agents with session tracking, event filtering, and live updates. The repository includes a hook system intercepting 12 event types, a Bun TypeScript server, a Vue 3 client, and optional Agent Teams (builder and validator). It requires Claude Code, Bun, Python with uv, and an Anthropic API key for integration.
The system captures 12 types of events (PreToolUse, PostToolUse, Notification, etc.) via Claude Code's hook mechanism, running corresponding Python scripts (e.g., pre_tool_use.py, post_tool_use.py) for validation, logging, and summarization. The send_event.py script sends event data (including tool name, session ID, source app) via HTTP POST to the server (default localhost:4000/events). The server (Bun + TypeScript) validates events, stores them in SQLite (WAL mode), and broadcasts to all connected clients via WebSocket. The Vue 3 client displays events in a real-time timeline, supports filtering by app, session, and event type, and includes a live pulse chart and chat transcript viewer.
- Individual developers who want to understand Claude Code's internal decision-making during coding, tracking every tool call.
- Teams using Claude Code across multiple projects needing centralized monitoring of agent activity and errors.
- Developers building multi-agent orchestration systems needing to track task creation, updates, and message passing across the swarm.
- Users who need to surface agent failures and permission requests early to prevent cascading issues.
- Those wanting to measure agent throughput and optimize multi-agent workflows.
What are this agent's strengths and limitations?
- Provides a real-time dashboard with a full timeline of all Claude Code events.
- Supports concurrent monitoring of multiple agents with filtering by agent swim lane.
- Includes security features like blocking dangerous commands and sensitive file access.
- Offers chat transcript viewing and a live pulse chart.
- Integrated Agent Teams for defining builder and validator roles.
- Only works with Claude Code, not other AI coding tools.
- Setup requires multiple components (server, client, hooks), with a learning curve.
- Requires an Anthropic API key, which may incur costs.
- The database stores event data, which could lead to disk space growth.
- Relies on WebSocket and HTTP communication; events won't be received if the network is down.
How do you install or deploy this agent?
Clone the repo and install dependencies: requires Claude Code, Astral uv, Bun (or npm/yarn), and the Python runtime. Copy the .claude directory to your project root: cp -R .claude /path/to/your/project/. Then edit .claude/settings.json to set the source-app parameter. Configure environment variables: create a .env file in the root with ANTHROPIC_API_KEY (required), optional OPENAI_API_KEY, ELEVENLABS_API_KEY, FIRECRAWL_API_KEY. In apps/client, copy .env.sample to .env and set VITE_MAX_EVENTS_TO_DISPLAY. Start the system: ./scripts/start-system.sh or just start.
How do you use this agent?
Ensure the server and client are running (default ports 4000 and 5173). Open http://localhost:5173 in your browser. In your project with Claude Code, run a command like git ls-files and watch events stream into the client. You'll see tool calls, session start/end, subagent activities. Use the filter panel to select app, session, event type. Manage via just commands: just stop to stop, just restart, just test-event to send a test, just health to check status.
How does this agent compare with similar options?
No explicit alternatives are mentioned, but similar observability tools might include Langfuse or LangSmith.