---
title: Eve observability
product: vercel
url: /docs/eve/observability
canonical_url: "https://vercel.com/docs/eve/observability"
last_updated: 2026-06-08
type: conceptual
prerequisites:
  - /docs/eve
related:
  - /docs/eve/concepts
  - /docs/observability
summary: View agent runs in the Vercel dashboard with no setup, and optionally export AI SDK spans through OpenTelemetry.
install_vercel_plugin: npx plugins add vercel/vercel-plugin
---

# Observability

Eve gives you two ways to observe an agent:

- **Agent Runs**: the primary view. Every Eve project gets a built-in Agent Runs dashboard in
  Vercel. It works by default with no instrumentation or configuration.
- **OpenTelemetry export**: optional. Send AI SDK spans to your own OpenTelemetry backend when you
  want traces alongside the rest of your stack.

## Agent Runs

Open your project in the Vercel dashboard and go to **Observability > Agent Runs**. This is the
primary observability surface for Eve, and it appears automatically for Eve projects, with no
instrumentation file required.

The overview shows:

- **Runs** over time, broken down by trigger (such as Slack and HTTP).
- **Token usage** over the same window, split into input, output, and cached tokens.
- A **table of runs** with the triggering message, trigger type, tokens in and out, turn count,
  duration, and time.

Select a run to drill into it. The run detail shows its model, trigger, and deployment, then a
per-turn breakdown with:

- **Timings** for each step in the turn, including skill loads and individual tool calls.
- **Input** and **Output** for the turn.
- **Reasoning** the model produced along the way.
- **Tool Calls** made during the turn, with their arguments and results.
- Input, cached, and output token counts for the turn.

Because this view is always on, it is the fastest way to confirm an agent is running in production
and to inspect what happened on any given session.

As the deployer, where your agent processes personal, sensitive, or regulated data, you may be
required to disclose this capture as required by applicable laws and in your privacy materials.

## Export AI SDK spans with OpenTelemetry

Agent Runs covers most needs on its own. If you also want AI SDK traces in an external backend, Eve
can export them through OpenTelemetry.

Eve auto-discovers `agent/instrumentation.ts` and runs it at server startup before any agent code.
Its presence enables telemetry, and there is no separate toggle. Register an OpenTelemetry provider in
the `setup` callback, which receives the resolved agent name:

```ts filename="agent/instrumentation.ts"
import { BraintrustExporter } from '@braintrust/otel';
import { defineInstrumentation } from 'eve/instrumentation';
import { registerOTel } from '@vercel/otel';

export default defineInstrumentation({
  setup: ({ agentName }) =>
    registerOTel({
      serviceName: agentName,
      traceExporter: new BraintrustExporter({
        parent: `project_name:${agentName}`,
        filterAISpans: true,
      }),
    }),
});
```

Any OpenTelemetry-compatible backend works, such as Braintrust, Honeycomb, Datadog, or Jaeger. Install the
exporter you need and configure it in the callback. The agent name is resolved at compile time from
your project, so you never hard-code a service name.

Three optional fields control what the AI SDK records inside those spans:

- `recordInputs`: record full message history on each step span (default `true`). Set to `false`
  for sensitive inputs or smaller payloads.
- `recordOutputs`: record model outputs on spans (default `true`).
- `functionId`: override the function name on spans (defaults to the agent name).

## Trace hierarchy

When telemetry is enabled, each turn produces a trace with a parent span per turn and child spans
for each model call and tool execution:

```text
ai.eve.turn  {eve.session.id}
  +-- ai.streamText                           step 1
  |     +-- ai.streamText.doStream            model call
  |     +-- ai.toolCall  {toolName: search}   tool exec
  +-- ai.streamText                           step 2
  |     +-- ai.streamText.doStream
  |     +-- ai.toolCall  {toolName: read}
  +-- ai.streamText                           step 3 (final text)
```

Eve injects session, turn, step, and channel context onto the spans (`eve.version`,
`eve.session.id`, `eve.environment`, `eve.turn.id`, `eve.turn.sequence`, `eve.step.index`,
`eve.channel.kind`). You can attach your own per-call values through the `events["step.started"]`
callback, which returns a `runtimeContext` object that rides onto the model-call span.

## Next steps

- [Concepts](/docs/eve/concepts): learn how Eve's runtime pieces fit together.
- [Observability](/docs/observability): the broader Vercel observability surface


---

[View full sitemap](/docs/sitemap)