# Understand your agents

> Canonical: https://www.overmindlab.ai/product/observability

*Observability*

Overmind builds a context graph from your code and your agent traces, so every prompt, tool, and decision path is mapped, and instrumented with live telemetry.

## The graph is the product

Most tools show you traces. Overmind builds a model of your agent and uses traces to keep it honest.

### One graph, every component

Connect a repo and Overmind maps each agent it finds: the system prompt, the tools, the control flow, and the input and output contracts, every one pinned to the file and line that defines it. Production spans attach to those same nodes, so the graph shows what your code declares next to what it actually did.

`File-and-line provenance` `Code beside runtime` `Paths that never ran`

### Instrument once, trace everything

A single SDK setup auto-instruments the LLM libraries you already use, over OpenTelemetry. Optional annotations add structure where you want it. No wrapper classes, no rewrites, no proprietary wire format.

`One-line setup` `OpenTelemetry native` `No rewrites`

### Live traces, scored on arrival

Every run lands with duration, tokens, cost, and eval scores attached, because your evaluators run on traces as they arrive. Open the span tree or flame chart to see the prompt, the tool calls it fired, and what came back, without digging through logs.

`Cost per run` `Scored as it lands` `Span tree to flame chart`

### Coverage reconciliation

Coverage checks every discovered component against your instrumentation and scores it: N of M components emitting telemetry. Each silent component is named, with a fix prompt matched to your stack, and a coding agent can write the instrumentation and open the PR against your repo.

`Every gap named` `Stack-matched fix prompt` `PR opened for you`

## What you get

Everything below ships with the SDK and the console. No collectors to run, no dashboards to build.

### Context graph

- **Component discovery** — Connect a repo and the scan maps agents, prompts, tools, and models, pinned to file and line.
- **Typed nodes and edges** — Agents, tools, prompts, datasets, and models are nodes. Edges record what called, trained, or scored what.
- **Graph as foundation** — Datasets, evals, and training runs all read from the graph. Fix it once and everything downstream improves.

### Tracing

- **Automatic instrumentation** — One SDK setup covers the LLM libraries you already use over OpenTelemetry, with no rewrites required.
- **Traces table** — Every run with duration, tokens, cost, and eval scores. Filter by agent, status, or session.
- **Span detail** — Per-span input, output, tools, and model usage (tokens, cost, finish reason), plus a flame chart.

### Coverage

- **Trace coverage score** — Every agent shows N of M discovered components instrumented, with each silent component named.
- **Fix coverage prompt** — A copyable fix prompt names each uninstrumented component, with guidance matched to your stack.
- **Instrumentation PR** — A coding agent writes the missing instrumentation and opens the PR. Closing gaps is a review.

## See your agents clearly

Instrument once. The graph builds itself.

- [Connect your repo](https://console.overmindlab.ai)

- Book a call: https://www.overmindlab.ai/contact