The dashboard

The dashboard at https://<your-org>.kcap.ai is where you live once sessions are flowing. It opens on a personalized Home; this page is an orientation to the surfaces behind it — what each shows, and what you’d open it for.

Layout

The dashboard is a single page with three regions:

• Repository sidebar (left, collapsible) — every repo you have access to. On Team/Enterprise plans it groups by project — each group collapsible, your choice persisted — otherwise by GitHub org. Click a repo to filter the list view to it; click “All repositories” to clear the filter.
• Tab bar (top) — Sessions / Agents / Analytics / Work Items. (The app lands on Home; these are the surfaces behind it.) When a specific repo is selected, two extra tabs appear: Facts and Curation (per-repo signal). The active tab determines what fills the list view.
• Split panel (right) — a list view on the left, a detail view on the right. The boundary is drag-resizable; the position is persisted in your browser.

This capture predates the Work Items tab, so it isn’t shown in the tab bar above.

URLs are canonical and shareable. https://<your-org>.kcap.ai/session/<slug> opens a specific session in the detail panel; the list view filters accordingly.

Sessions tab

The session archive at /sessions — every session you have permission to see, newest first (this is where Home links you to browse). Each row shows:

• The session owner’s avatar and name
• The repo (or “no repo” for sessions outside a git working tree)
• The harness (Claude, Codex, Gemini, Pi, OpenCode, Antigravity, Copilot, Cursor, or Kiro) and model
• A compact stats row: token totals, tool calls, file changes, elapsed time
• A context-occupancy chip — how full the context window got (e.g. 142k / 200k)
• An eval rating — a colour-coded 5-star score once the session has been scored (and a “not evaluated” marker on eligible sessions that haven’t been), refreshed live the moment a score lands
• Live status — running, ended, errored — updated in real time via SignalR

Click any row to open the session detail. An ended session opens on Overview; a live session opens on Transcript. Six tabs, each pitched at a different question:

Overview — what did this session accomplish?

The default tab for an ended session: the generated outcome — what got done, the plan behind it, and what to try next — with the full transcript one click away when you want the detail. See Session outcomes.

Transcript — what did the agent and I actually say to each other?

A read-only reconstruction of the conversation, faithful to what the harness displayed at the time. User prompts, assistant messages, tool calls and their results, thinking blocks, and subagent invocations all render inline in the order they happened.

Every assistant turn and every subagent call carries its own token tally inline, in Capacitor’s canonical shape — in → out (Σ) with cache reads and writes broken out separately (r / w), so a turn’s real work isn’t drowned out by the large context it re-reads each time. Where the model’s pricing is known, a per-model cost chip (≈ $…, estimated from models.dev rates) sits alongside. Hover any turn to see its wall-clock time and the model that produced it. This is the surface most reviewers spend their time in.

Long sessions stay cheap to open. Once a session (or a whole continuation chain) runs past ~15 turns, the older turns collapse into one-line cards — prompt excerpt, model, the same token breakdown, and file/tool/error counts — with the most recent turns left expanded; click a card to expand that turn in place. Slash-commands and other local commands render as labeled rows (the command, then its output) rather than raw markup.

Events — what actually happened, in order, with what it cost?

The append-only event stream that backs the session, newest first. Every hook fire, every tool call, every thinking block, every diff, every status change is a row, with the exact tokens spent and the time it took.

Use this when the Transcript doesn’t tell you enough — when you need to know that a Bash call took 47 seconds before it returned, when a hook ran and what it produced, the precise byte-level diff an Edit applied, or which turn the context window jumped on. Because events flow in newest-first and update live, watching this tab while a session runs is the closest thing to looking over the agent’s shoulder.

Trace — how is this session structured?

A turn-grouped, hierarchical view of the same data. Turns roll up the assistant message, its tool calls, and any spawned subagents into a single collapsible node, annotated with the model used and the tokens consumed for that turn. Expand a turn to see its children; expand a subagent to descend into its own trace.

Trace is the view to reach for when you’re trying to understand shape — where the long tail of cost lives, how deeply subagents nested, which turns triggered context compaction.

Evaluation — how good was it?

The LLM-judge result for the session: an overall score, a retrospective with concrete “try next time” suggestions, and a per-category breakdown. It’s empty until the session is scored — kick that off with Evaluate session here. See Evaluations.

Details — metadata

Repo, branch, PR linkage, ownership, visibility, harness, model, and token usage.

The detail header also carries a few affordances: a regenerate-title button (when the server has a title model configured) to re-run title generation on demand; for resumed or compacted sessions, a continuation-chain row linking every session in the chain — a member you can’t see shows as …(private) — with matching “continues from” / “continued as” links in the Events stream; and for forked Pi sessions, a branch picker for viewing any branch (the URL carries ?branch=…, and a non-active branch shows a back-to-active link).

Agents tab

A flattened view of agent instances — every Claude / Codex / Gemini / Pi / OpenCode / Antigravity / Copilot / Cursor / Kiro instance that has produced sessions, with the most recent activity surfaced. Useful when you want “what is everyone working on right now” rather than “what was the last session in this repo”.

Hosted agents (launched from the dashboard via your daemon) appear here too: each connected daemon shows as a row with an online dot, its version, and a running-agent count, plus a launch button to start a new instance on it. Agent cards carry a model chip, matching the session list. See Hosted agents.

Analytics tab

Ask questions about your sessions in natural language. The Analytics tab is a chat box — “Ask about sessions, tools, evals…” — that turns a plain-English question into a query over your session read model and answers with a short written summary plus a table or chart.

Two examples:

• “Across all repositories, who was my most prolific developer?” → a ranked table of developers by sessions, repositories, and total events.
• “Show my daily token spend by developer by day.” → a grouped bar chart of input + output tokens per day, one series per developer.

Every answer shows the query_read_model calls behind it, so you can see the query that produced the number, and it respects the same visibility rules as the rest of the dashboard — you only get data for sessions you can see. See Analytics for more example questions and how it works.

Work Items tab

Groups sessions into the lines of work they served — each card is a work item (an issue, a PR, or an ad-hoc effort) with its linked keys and attached sessions. Correlated automatically from the references in your sessions; the list updates live. See Work items for how attachment works and how to declare one from inside an agent.

Repo-scoped signal tabs

Selecting a repo reveals two additional tabs: Facts and Curation.

Facts lists individual findings produced by evaluations. Use it to mute correct-but-noisy facts, delete incorrect findings with a reason, and keep only useful evidence flowing into clustering.

Curation groups retained facts into recurring repo patterns. Anyone with repo visibility uses it to promote useful lessons, dismiss stale clusters, watch regressions, and decide which guidance is injected into future sessions.

For the end-to-end workflow, see Facts & curation.

Live updates

Ingest is real-time with sub-second latency end-to-end. The CLI streams each event to your Capacitor server as the agent emits it; the server projects it and pushes it to every connected dashboard over SignalR. From the moment a tool call returns in the terminal to the moment its row appears in the Events tab is typically well under a second.

In practice that means you can keep a session open in the dashboard while a teammate (or a hosted agent) is driving it and watch the conversation, the tool calls, and the token counter advance in lockstep with the terminal. New sessions appear in the list without a refresh. Token counts tick as the agent runs. The detail panel updates if someone else changes visibility on a session you have open.

If you see “Reconnecting…” in the corner, the SignalR connection dropped and is re-establishing. No action needed; missed events backfill on reconnect.

Searching and filtering

• Repo sidebar filters by repo.
• Tab bar filters by surface — the global tabs (sessions / agents / analytics / work items), plus per-repo Facts and Curation when a repo is selected.
• The session list supports a free-text filter (top of the list panel) that matches repo name, owner, and slug.
• For PR-linked sessions, the kcap review command gives you a structured query interface over the transcripts via MCP.

Related

• Home & projects — the landing page and how repos group into projects.
• Session outcomes — the Overview tab in depth.
• Visibility & sharing — who sees which sessions, and how to share.
• Hosted agents — launching agents from the dashboard.