Skip to main content
LLM observability turns a Vercel AI SDK call inside a task into its own span in the run trace, next to your logs and other spans. Each span carries the model, provider, input, output, and total token counts, cost, and latency, so you can see what each generation did and what it cost without leaving the run. Everything shows up inline in the run trace you already use to debug runs. There is no separate product and no dashboard to set up.
Observability only covers Vercel AI SDK functions (generateText, streamText, generateObject). On AI SDK 5 and 6 it’s opt-in per call. On AI SDK 7, once the @ai-sdk/otel adapter is registered, every call is traced, including its prompts and responses, unless you pass telemetry: { isEnabled: false }. Calls you make with a raw fetch, a provider’s own SDK, or any other HTTP client are not captured automatically.

Turn it on

Set experimental_telemetry: { isEnabled: true } on the AI SDK call. There is nothing to configure on the Trigger.dev side.
AI SDK 7 moved span emission out of ai core into the @ai-sdk/otel adapter. In a task, install @ai-sdk/otel and register it once yourself, for example at the top of your task file:
/trigger/summarize.ts
Register it the same way in projects with chat.agent() runs too: the static import is what includes @ai-sdk/otel in your deployed bundle. chat.agent() detects the existing registration and won’t add a second one.Once the adapter is registered, AI SDK 7 traces every call by default, so the per-call flag is optional. To leave a call out, pass telemetry: { isEnabled: false } (telemetry is the non-deprecated name for experimental_telemetry). On AI SDK 5 and 6, ai core emits spans directly and no adapter is needed.
/trigger/summarize.ts
Trigger the task and open the run. The generateText call appears as a span in the trace. streamText and generateObject work the same way: add the same experimental_telemetry flag to each call you want captured.

What each span shows

Open an AI generation span in the run trace to get a dedicated inspector with three tabs:
  • Overview: model, provider, token usage, cost, and a preview of the input and output.
  • Messages: the full message thread, including the system prompt and any tool results.
  • Tools: the tool definitions passed to the model, plus every tool call the model made with its arguments.
A fourth Prompt tab appears when the call is linked to an AI Prompt (see below). If you manage prompts with AI Prompts, resolve the prompt and spread toAISDKTelemetry() into the call. This sets experimental_telemetry for you and links the span back to the exact prompt version that produced it.
Prompt linking currently works on AI SDK 5 and 6. On AI SDK 7, the metadata from toAISDKTelemetry() doesn’t reach the span yet, so the call is traced but isn’t linked to its prompt version or given the custom attributes.
/trigger/support.ts
The span’s Prompt tab now shows the linked template, its version, and the input variables the prompt was resolved with. Pass custom attributes to toAISDKTelemetry() to tag the span with your own metadata:
Custom attributes are stored on the span’s metadata, so you can filter or group by them in TRQL, for example metadata['task.type'].
When you build an agent with chat.agent() and store a prompt with chat.prompt.set(), chat.toStreamTextOptions() sets experimental_telemetry for you, so those generations are captured without adding the flag by hand. Without a stored prompt, set experimental_telemetry on the call yourself. See Prompts.

Query usage across runs

Every captured generation is also written to the llm_metrics table, which you can query with TRQL. This lets you aggregate token usage, cost, and latency across many runs rather than inspecting one span at a time. Cost and token usage by model:
Spend per task:
Cost by prompt version, when calls are linked to an AI Prompt:
Set the time window with the query’s period filter rather than in the SQL itself. Run these from the Query dashboard, the SDK with query.execute(), or the REST API. llm_metrics also exposes ms_to_first_chunk and tokens_per_second for latency and throughput, plus finish_reason, request_model, cached_read_tokens, reasoning_tokens, and per-direction input_cost / output_cost for finer breakdowns.

Next steps

Prompts

Version prompts as code and link generations to the exact prompt version that produced them.

Query (TRQL)

Write custom queries against your runs, metrics, and LLM usage.