---
title: Developer views
description: The deep-dive tabs — Flow, Models, LLM Context, Agent Graph, Tools, Context usage, Runtime extras and Ask — and what each one is genuinely useful for.
keywords: agent flow visualization, agent graph, tool catalog latency, context window usage, LLM context inspection
eyebrow: Dashboard
---

# Developer views

Eight tabs for when the top-level pages have told you *that* something is wrong
and you need to know *why*.

## Flow

An animated architecture diagram that lights up as messages move through the
system: channel → gateway → model → tools → back. Colour-coded by type, with
errors in red.

It is the fastest way to build a mental model of where time and money go in a
turn, and the fastest way to spot a stage that is silently failing — a channel
that never lights up is a channel that is not delivering.

```bash
curl -s localhost:8900/api/flow | jq
curl -s localhost:8900/api/component/gateway | jq
curl -s localhost:8900/api/component/brain | jq
```

Clicking any component opens its detail: the tool's call count and latency
percentiles, the runtime's configuration, the machine's resources, the
gateway's connection state.

## Models

Per-model behaviour rather than per-model cost. Which models you actually use,
their latency distribution, their error rates, and how usage has shifted over
time.

The routing question — "should this task be on a cheaper model?" — starts here
and ends in [Reducing spend](/docs/cost/optimization/).

## LLM Context

What the model actually saw on each turn.

This is the tab that resolves arguments. An agent that "ignored the
instructions" usually did not receive them — because a compaction dropped them,
or a file read returned less than expected, or a system prompt was overwritten.
The context view shows the assembled input rather than what you assume it was.

```bash
curl -s localhost:8900/api/context-anatomy | jq
```

## Agent Graph

Cross-session spawn topology, built from span data. Which agent spawned which,
how deep the tree went, and what each branch cost.

On a fleet running orchestrators — QM, Hermes, OpenClaw with sub-agents — this
is the only view where the real shape of the work is visible. A three-level
delegation tree looks like eight unrelated sessions everywhere else.

```bash
curl -s 'localhost:8900/api/local/agent-graph?limit=500' | jq '.nodes | length'
```

## Tools

Every tool the agent uses, by provenance, with call count and p50/p95 latency.

Provenance matters: a built-in tool, an MCP server's tool and a skill-provided
tool behave differently and fail differently, and a catalogue that merges them
hides the pattern. The MCP server list is here too, with per-server statistics.

```bash
curl -s localhost:8900/api/tool-catalog | jq '.tools[:10]'
curl -s 'localhost:8900/api/tool-catalog/<name>/calls' | jq
curl -s localhost:8900/api/mcp-servers | jq
curl -s localhost:8900/api/mcp-stats | jq
```

A tool with a p95 far above its p50 is usually the reason a session felt slow.

## Context usage

Context-window utilisation over time, compaction triggers, and tokens reclaimed.

Compaction is expensive and lossy, and a session that compacts repeatedly is
usually solvable — by trimming what gets loaded rather than by upgrading the
model. This tab shows you the pattern.

```bash
curl -s localhost:8900/api/context-economics | jq
curl -s localhost:8900/api/usage/compression | jq
```

:::note One trap worth naming
Some runtimes report a cumulative `prompt_tokens` that sums the re-read of
context on every turn. That is billing-shaped, not context-shaped, and it is not
your context size. ClawMetry keeps the two distinct — see
[OpenHands](/docs/runtime/openhands/) for the clearest example.
:::

## Runtime extras

What the selected runtime uniquely exposes, beyond the generic tabs. The tab is
hidden unless the current runtime has extras.

Examples: Grok's manifest of the codebase archives it staged for upload; Cline's
rejected tool calls and its schedule executions; Copilot's credit ledger;
Kimi's context-window occupancy; Devin's abandoned branch count.

```bash
curl -s localhost:8900/api/harness/data | jq
```

## Ask

Plain-English questions about your own agent usage, answered from the store.

```bash
curl -s localhost:8900/api/advisor/ask -X POST \
  -H 'content-type: application/json' \
  -d '{"question": "which runtime grew fastest in cost last month?"}' | jq
```

Saved questions become **dives** you can re-run. If you would rather your coding
agent asked these questions as part of its own work, that is
[the MCP server](/docs/mcp/overview/).