Documentation

The heart of ClauBoard — a draggable canvas where every agent is a card you can move, inspect, and control.

• Drag agents freely on the canvas to organize your workspace
• Connection lines between agents show dependencies and data flow
• Lines change color based on status: green (active), purple (completed), red (blocked), amber (bypassed), gray (idle)
• Click any agent to open the Detail panel with full event stream, output, tools, and files
• Toggle between Canvas (free-form) and Grid (structured) views
• Export agent state as JSON from the canvas
• Dot-grid background for spatial orientation

Chain agents into dependency graphs. Build multi-step workflows where each agent waits for its prerequisites.

• Create sessions with multiple agents and define dependencies between them
• Launch presets like 'Parallel Analysis Pipeline' with one click — 5 agents analyze in parallel, then an aggregator combines results
• The SessionOrchestrator validates the dependency graph before launching
• Each stage waits for its dependencies to complete before starting
• Failover: if an upstream agent fails or is stopped, downstream agents still launch with a context warning instead of blocking the entire chain
• Visual connection lines show the pipeline flow in real time

Send follow-up instructions to agents while they work. No need to stop and restart — just redirect in real time.

• Open the Agent Detail panel and type a message in the input field
• The message is sent to the agent's stdin — Claude Code reads it as operator input
• Use this to clarify requirements, provide missing context, or change direction
• Messages appear in the event timeline as 'stdin' entries
• Works with real Claude Code CLI — the agent processes your message and adjusts its approach

Every tool call, file edit, terminal output, and status change streams to the UI in real time via WebSocket.

• Events are append-only and replayable — server replays on startup to rebuild state
• Virtual scrolling handles 50,000+ events without lag (powered by @tanstack/react-virtual)
• Filter by event type (tool.invoked, file.changed, terminal.output, etc.) or by agent
• Timeline page shows all events across all agents in chronological order
• Agent Detail panel shows events scoped to a single agent
• Events are persisted to JSONL (default) or SQLite for production use

When one agent completes, the next in the pipeline receives a structured summary of what was done.

• The system collects: files created/modified, tool calls made, key terminal output
• This context is injected into the downstream agent's prompt automatically
• Example: 'Agent Analyst completed. Files created: research.md, data/metrics.json. Tools: Read (5), Write (2). Read research.md for results.'
• If an upstream agent failed, the downstream agent is warned: 'Note: upstream agent failed. Proceeding with available context.'
• All agents in a session work in the same project directory — they can read each other's file output directly

Production-ready with Docker, dual storage backends, event archival, and a plugin system for extensibility.

• Docker: multi-stage build, docker-compose with mock and real profiles
• Storage: JSONL (default, simple) or SQLite with WAL mode (production, indexed queries)
• Event archival: archive old events to timestamped files, compact verbose events
• Auto-compact when event count exceeds threshold (configurable via COMPACT_THRESHOLD)
• Plugin system: register custom event types, notification rules, and lifecycle hooks
• Built-in metrics plugin tracks tool calls, errors, files modified, and run durations

Built-in alert rules monitor agent health and notify you when something needs attention.

• 5 built-in rules: run failed, agent blocked, tool errors (>3), long-running (>5min), task failed
• Alerts appear in the Office header with severity-colored badges
• Acknowledge alerts to dismiss them
• Custom rules can be added via the plugin system
• Alert history is persisted — review past incidents after the fact

Extend ClauBoard with custom event types, notification rules, and processing hooks.

• Plugins define: name, version, custom event types, notification rules, and lifecycle hooks
• onRegister: initialize plugin state when loaded
• onEvent: process every event that flows through the system
• onDestroy: clean up resources when unloaded
• Built-in metrics plugin as reference implementation
• API: GET /api/plugins (list), GET /api/plugins/event-types (custom types), POST /api/plugins/emit (inject events)

Demo the full product without Claude Code CLI. Six simulated agents generate realistic events.

• Run `npm run dev:mock` — no API key or CLI needed
• 6 agents: Alice (Frontend), Bob (Backend), Carlos (DevOps), Diana (Security), Eve (Docs), Linter (QA)
• Each agent cycles through realistic prompts: rate limiting, database migration, Docker builds, security reviews
• Agents complete runs, take breaks, then start new tasks — simulates a live office
• Stop/pause individual agents from the UI
• Launch additional agents or pipelines on top of the mock agents
• Demo sessions are auto-created showing pipeline and team patterns

Control what agents can access and where they can run.

• ALLOWED_WORKSPACE_ROOTS: restrict which directories agents can use as working directory
• All agent processes run as child processes of the server — no external network access by default
• Events are local-only (JSONL/SQLite in data/ directory) — no cloud dependency
• WebSocket connections authenticated via session token (when auth is enabled)
• Environment variables for all configuration — no config files to leak

We're transparent about what's not done yet. These are actively being worked on.

• Local only — runs on localhost. Authentication and multi-user support are on the roadmap
• Trusted environment required — uses --dangerously-skip-permissions for non-interactive agent runs. Run in development environments only
• File detection is approximate — catches Edit/Write tool calls but may miss files changed via Bash commands
• Single Claude Code provider — support for Cursor, Copilot, and other agents is planned