---
title: "Browse and debug conversations | Grafana Cloud documentation"
description: "Search, filter, and drill into conversations to understand what your agents did, where they failed, and how they performed."
---

> For a curated documentation index, see [llms.txt](/llms.txt). For the complete documentation index, see [llms-full.txt](/llms-full.txt).

# Browse and debug conversations

The Conversations view in Agent Observability lets you search, filter, and inspect full conversation threads. Use it to understand what happened during an agent interaction, identify failures, and analyze performance.

## Choose a task

Start with search and inspection, or jump to the task you need:

- **Find and inspect a conversation**: Refer to [Search conversations](#search-conversations) and [Inspect a conversation](#inspect-a-conversation).
- **Investigate behavior and failures**: Refer to [Debug an agent response](#debug-an-agent-response) and [Debug guard and tool failures](#debug-guard-and-tool-failures).
- **Understand cost and execution**: Refer to [Interpret conversation cost](#interpret-conversation-cost), [Dependencies and Workflow](#understand-the-dependencies-and-workflow-tabs), and [Drill down into traces](#drill-down-into-traces).
- **Review quality with your team**: Refer to [Correct an evaluation score](#correct-an-evaluation-score), [Provide feedback](#provide-feedback), and [Annotate conversations](#annotate-conversations).
- **Reuse examples**: Refer to [Save conversations](#save-conversations) for review and experiments, or [Download conversations](#download-conversations) for offline review.

## Before you begin

- Send conversation data from an instrumented agent to Agent Observability.
- Use the Agent Observability Reader role or a role with conversation read permission.

## Search conversations

Go to **Conversations** in Agent Observability. Use the search bar and filters to find conversations by:

- Time range.
- Agent name or version.
- Model provider or name.
- Conversation content.
- Error status.
- Tags or metadata values.
- Evaluation results (pass, fail, or specific evaluator scores).
- Feedback ratings (thumbs up or thumbs down).

Conversations display a summary showing the agent, model, token count, cost, duration, and any evaluation scores. The metrics bar shows evaluation pass, fail, and neutral counts for each conversation.

To omit specific providers, models, or agents, use **Exclude selected** in the corresponding filter. For instructions, refer to [Include or exclude traffic](/docs/grafana-cloud/observe-and-act/agent-observability/observe-and-troubleshoot/dashboards/#include-or-exclude-traffic).

## Inspect a conversation

Click a conversation to open the detail view. **Flow** opens by default, even when the conversation has dependency or workflow data. A shared link can open a different view. The conversation detail shows:

- A timeline of all generations in the conversation.
- Each generation’s input messages, output messages, tool calls, and tool results.
- Image and video media parts when captured by your SDK.
- Token usage breakdown (input, output, cache read, cache write, reasoning).
- Timing data (start, first token, end).
- Agent context, including the agent version, system prompt, and tool definitions captured for the generation.
- Evaluation scores attached to each generation.

Tool calls within a generation are grouped together, and thinking/reasoning content is collapsible. Renderable image and video content appears inline in the thread, generation detail, and tool result cards. Media references that the browser can’t render directly show a placeholder with the stored reference instead. Generations with no captured content show an inline placeholder.

In the conversation tree, use the arrow beside a call to expand or collapse its child tool executions. When captured tool-call IDs identify the requesting generation, tool executions appear beneath that generation, including tools run by asynchronous workers. This keeps the tool’s result with the call that requested it rather than another agent that shares its trace parent.

Tool cards in the thread and generation detail show execution duration when a matching tool execution span is loaded. If no matching span is available, the card doesn’t show a duration. Missing timing doesn’t mean the tool takes no time, and gaps between generations aren’t used to estimate tool duration.

Click the agent context label on a generation to open **Generation context**. Review **Agent version**, **System prompt**, and **Tools** when captured. Click **Open agent page** to inspect the agent in the catalog.

Select the error badge in the metrics bar to jump directly to the first errored generation in the conversation.

Hover over a truncated conversation title to read the full title. Click **Copy conversation title** beside it to copy the complete text. In the expanded header, **Copy conversation ID** copies the identifier separately. If the conversation has no title, the header shows the ID and its copy control instead.

Click **Collapse details** to hide secondary header details and AI analysis while keeping actions and key totals visible. Click **Show details** to restore them. Your choice persists when you reload or open another conversation.

## Debug an agent response

Open a generation and find **Debug this agent response**. Enter a question about the selected step, for example, “Why did you choose this action?”, then click **Run follow-up**.

The one-off request uses the captured system prompt and conversation history up to that step. It uses the original model when available, or a configured fallback. Check **Model** below **Follow-up response** to confirm which model answers.

If earlier context is trimmed, a warning indicates that the answer might be incomplete. Treat the response as a debugging aid, not proof of why the original agent acted.

## Debug guard and tool failures

Conversation details show guard outcomes alongside the generations they affected. Use these events to confirm whether a preflight guard allowed, denied, warned, or redacted a request before the model call. Guard events help explain why a generation is missing, why the request content changed, or why a request was blocked.

Tool analytics can link errored tools back to example conversations. Open an example conversation from a tool error to inspect the exact generation, tool call arguments, tool result, and surrounding thread that produced the failure.

## Interpret conversation cost

Each call uses the configured model price in force when it completes, or the public list price when you haven’t configured one. Hover over a cost to check its price source. A conversation can combine calls priced from your configured rates and public list rates.

If your configured rates can’t be loaded, the tooltip explains that the displayed estimate uses public list rates. Don’t treat that fallback as confirmation of your contract price. For how price changes and deletions affect costs, refer to [Configure your model prices](/docs/grafana-cloud/observe-and-act/agent-observability/observe-and-troubleshoot/model-prices).

## Understand the Dependencies and Workflow tabs

Conversation detail has two graph views for agent structure: **Dependencies** and **Workflow**. They represent different layers of your agent, and you can use both together.

### Inspect the generation DAG in Dependencies

Use **Dependencies** to inspect relationships between LLM calls. Each node is one generation, and edges come from `parent_generation_ids`. You set these parent IDs explicitly in your code; no SDK layer fills them automatically.

This tab is always available. If no generation declares parents, it still shows independent nodes and an inline hint that no dependencies were instrumented. Dependencies work across processes and services because the IDs are just strings you forward over the wire.

### Review the agent execution graph in Workflow

Use **Workflow** to inspect the full orchestration around your LLM calls. Each node is an agent execution step, for example, routing, planning, retrieval, validation, or tool orchestration. A step can wrap zero, one, or many generations. A retrieval step with no LLM call still appears in the graph with its state, duration, and errors.

Steps link to each other with `parent_step_ids` and link to the LLM calls that happened inside them with `linked_generation_ids`. You can build this graph in two ways. Supported framework adapters fill both fields automatically when workflow-step capture is enabled. The core SDK can also send workflow steps manually to represent your custom orchestration. The **Workflow** tab appears only when the conversation includes workflow-step telemetry.

### Choose the right view

Expand table

| Situation                                                            | Recommended view                                                                                                              |
|----------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------|
| Using a framework adapter with workflow-step support                 | Enable workflow-step capture. **Workflow** shows the full graph automatically.                                                |
| Building your own orchestration without a framework                  | Send workflow steps manually with the core SDK. **Workflow** shows your custom execution graph.                               |
| Calling LLMs directly via provider wrappers with no framework        | Forward `parent_generation_ids` between calls. **Dependencies** shows the generation DAG.                                     |
| Connecting calls across different services or processes              | Pass the upstream generation ID over the wire and set it as the parent on the next call. **Dependencies** stitches the graph. |
| Non-LLM work (vector search, ranking, routing) that you want visible | Use **Workflow**. A step with zero generations still appears in the graph. Dependencies can’t show non-LLM nodes.             |

You can combine both: **Workflow** gives the high-level execution path, while **Dependencies** gives the generation-level DAG for debugging multi-agent handoffs and downstream quality signals.

## Drill down into traces

Each generation links to its OpenTelemetry trace. Select the trace link to open the trace view in Tempo, where you can inspect the full span tree including:

- LLM call duration and error status.
- Tool execution spans.
- Nested agent invocations.

Use trace drilldown to identify latency bottlenecks, understand tool call sequences, and diagnose timeout or error scenarios.

## Open conversations from traces

In Grafana Trace view, traces with generative AI attributes include **View in Agent Observability**. Click it to find the conversation associated with the trace. On a `gen_ai.conversation.id` attribute, open **Open value in** and select **View conversation** to open the conversation at the selected span.

Use these links when you start with a trace from an alert, dashboard, or Explore and need its conversation, generation details, and evaluation scores.

## Correct an evaluation score

With the Agent Observability Admin role or evaluation write permission, you can correct a score:

1. Open a conversation and select an evaluation score.
2. Change **Score value** or **Pass/fail outcome**. Only fields you change are overridden.
3. Optionally add **Override notes**.
4. Click **Save override**, or **Update override** to change an existing override.

Agent Observability keeps the raw evaluator output and shows the effective override, who last changed it, and when. Click **Clear override** to restore the raw score. Use overrides for reviewed exceptions; update the evaluator or rule when the same correction is needed repeatedly.

## Provide feedback

Use feedback to capture human judgment about a conversation. Users with the Feedback Writer or Admin role can add ratings and annotations from the conversation detail view.

Use the feedback controls in the conversation header to mark a conversation as good or bad and optionally add context. Ratings appear in the conversation list and detail header so reviewers can quickly find conversations that need attention.

## Annotate conversations

Open the **Annotations** panel from the conversation detail view to add threaded notes. Annotations support key-value tags and are visible to all team members with the Feedback Writer or Admin role. Use annotations to:

- Flag conversations for review.
- Add context about specific agent behaviors.
- Track investigation notes alongside the conversation data.

The conversation list shows an annotation count badge, and you can browse annotated conversations from a dedicated pane in the conversation browser.

## Save conversations

Save conversations that you want to review later or reuse in evaluation workflows. Saved conversations appear in the **Saved** tab in the conversation browser.

Organize saved conversations into collections. Collections let you group representative examples, failure cases, or review sets that you can [reuse in offline SDK experiments](/docs/grafana-cloud/observe-and-act/agent-observability/evaluate-and-improve/experiments).

## Download conversations

Use the conversation list or detail view to download a conversation for offline review, support handoff, or regression-test authoring. Downloads include the captured conversation content and generation metadata that your SDK exported. They don’t include data that your SDK didn’t capture, such as coding-agent prompt content when the integration is in metadata-only mode.

## Next steps

- [Use the agent catalog](/docs/grafana-cloud/observe-and-act/agent-observability/observe-and-troubleshoot/agent-catalog)
- [Monitor agents with analytics](/docs/grafana-cloud/observe-and-act/agent-observability/observe-and-troubleshoot/dashboards)
- [Build and version test suites](/docs/grafana-cloud/observe-and-act/agent-observability/evaluate-and-improve/experiments/#build-and-version-test-suites)