Vercel Eve Observability & Monitoring with OpenTelemetry

eve is Vercel's filesystem-first framework for building agents. It traces every turn with OpenTelemetry, so each model call, tool execution, and subagent dispatch becomes a span with no instrumentation package to add.

This guide sends those traces from the interactive eve dev terminal UI to SigNoz.

What is Eve Observability?

Eve observability is the practice of collecting traces from eve agents so you can see what each turn did: which model steps it took, how many tokens it consumed, which tools and subagents it called, and whether it completed, failed, or was cancelled.

With full eve observability in SigNoz, you can follow a conversation turn by turn, attribute token spend to an agent or a model, catch tools that fail while the agent quietly recovers, and alert on turns that fail after exhausting their model retries.

Prerequisites

• A SigNoz Cloud account and an ingestion key
• Node.js 24 or later
• An eve project. Create one with npx eve@latest init my-agent
• A model credential connected in the eve terminal UI, such as an OpenAI API key

Monitor Eve with OpenTelemetry

eve loads every file in agent/instrumentation/ at startup. A file that exports otelIntegration() adds an OpenTelemetry destination, so sending traces to SigNoz takes one file.

Step 1: Install the OTLP exporter from @vercel/otel.

npm install @vercel/otel

Step 2: Add the SigNoz settings to .env.local in the project root. eve dev loads this file automatically.

OTEL_SERVICE_NAME=<service_name>
SIGNOZ_OTLP_ENDPOINT=https://ingest.<region>.signoz.cloud:443
SIGNOZ_INGESTION_KEY=<your-ingestion-key>

Verify these values:

• <service_name>: The name your agent appears under in SigNoz, for example support-agent.
• <region>: Your SigNoz Cloud region.
• <your-ingestion-key>: Your SigNoz ingestion key.

Step 3: Create agent/instrumentation/signoz.ts.

import { OTLPHttpProtoTraceExporter } from "@vercel/otel";
import { otelIntegration } from "eve/instrumentation/otel";
 
const AGENT_SPANS = /^(invoke_agent|agent\.step|agent\.action|chat|execute_tool)( |$)/;
 
export default otelIntegration({
  // Keep eve's agent spans and drop the durable-workflow runtime spans.
  exportPolicy: { span: ({ name }) => ({ emit: AGENT_SPANS.test(name) }) },
  traceExporter: new OTLPHttpProtoTraceExporter({
    url: `${process.env.SIGNOZ_OTLP_ENDPOINT}/v1/traces`,
    headers: { "signoz-ingestion-key": process.env.SIGNOZ_INGESTION_KEY! },
  }),
});

Step 4: Start the terminal UI and send a message.

npm run dev

Each turn is exported when it finishes. Allow up to 30 seconds for it to appear in SigNoz.

import { otel } from "eve/instrumentation/otel";
 
export default otel({
  resource: { "deployment.environment": process.env.VERCEL_ENV ?? "development" },
});

View Eve Traces in SigNoz

Open the Traces explorer and filter on your service.name. Each turn appears as an invoke_agent <agent> span with its agent.step, chat, agent.action, and execute_tool spans.

Click an invoke_agent span to open the turn. The waterfall shows the first model step requesting a tool, the tool running, and the second step writing the answer. Select a chat span to see the model, token counts, and conversation id on the right.

The span tree a turn produces looks like this:

invoke_agent <agent>          one trace per turn, carries agent.turn.outcome
└─ agent.step                 one per model step
   ├─ chat <model>            carries gen_ai.request.model and gen_ai.usage.*
   └─ agent.action            one per tool or subagent call
      └─ execute_tool <tool>

A few placement details matter when you write your own queries:

• Tokens appear three times. invoke_agent, agent.step, and chat spans all carry the same usage totals. Sum gen_ai.usage.* on chat spans for totals, and use invoke_agent only for per-agent breakdowns.
• Read turn outcomes from agent.turn.outcome. When a user presses Escape, the invoke_agent span stays unset with agent.turn.outcome = cancelled, while its child spans are marked as errors with TurnCancelledError. A has_error filter therefore counts cancellations as failures.
• Tool errors stay on the tool. A tool that throws marks its execute_tool and agent.action spans as errors, but the model recovers and the turn completes. A model call that fails after its retries does fail the turn.
• Subagents are separate traces. A subagent turn is its own invoke_agent trace, linked to its caller and sharing the caller's gen_ai.conversation.id. Its tokens are not rolled into the caller's turn.
• Provider-executed tools have no tool span. Tools the model provider runs itself, such as OpenAI web search, appear as agent.action spans without an execute_tool child.

Capturing prompts and completions

eve records prompts, completions, and tool arguments on spans by default in eve dev, and in production only when the channel's audience is public. Content lands on gen_ai.input.messages and gen_ai.output.messages, and each chat span repeats the full conversation history.

To stop recording content, set a tracePolicy in agent/instrumentation/otel.ts. Spans, timings, and token counts are still exported.

import { otel } from "eve/instrumentation/otel";
 
export default otel({
  tracePolicy: () => ({ emit: true, recordInputs: false, recordOutputs: false }),
});

The policy applies to every OpenTelemetry destination, not only SigNoz. If you also set deployment.environment, put resource and tracePolicy in the same otel() call, since eve allows only one.

Eve Observability Dashboard

SigNoz ships a prebuilt dashboard for eve covering turns, conversations, token usage by model and agent, latency, tools, subagents, turn outcomes, and errors. See the Eve dashboard for the panel reference and the import link.

Related integrations

If you build agents with other parts of the Vercel stack, or on another TypeScript framework, instrument them with the same OpenTelemetry pipeline:

• Vercel AI SDK observability with OpenTelemetry - model calls and tool use in apps built directly on the AI SDK
• Vercel Sandbox observability with OpenTelemetry - sandboxed code execution
• Mastra observability with OpenTelemetry - another TypeScript agent framework
• OpenAI Agents SDK observability with OpenTelemetry - agent runs, handoffs, and guardrails

Browse all LLM observability integrations to instrument the rest of your stack.