Build AI Agent Observability with Sentry + Vercel Analytics (2026)

TL;DR — Sentry's April 2026 update auto-instruments OpenAI, Anthropic, Google GenAI, LangChain, LangGraph, OpenAI Agents SDK, and Vercel AI SDK. Token, tool, and span data lands in Sentry Agent Insights with no manual span code.

What you'll build

A Next.js 15 app with: (1) Sentry capturing every LLM call as a nested span, (2) Vercel Web Analytics tracking conversion to "first message", and (3) OpenTelemetry export from Vercel AI SDK to Sentry.

Prerequisites

1. @sentry/nextjs@^9, @vercel/analytics@^1.4.
2. Sentry org with AI Agent Monitoring enabled.
3. Vercel project for hosting.

Architecture

flowchart LR
  UI[Next.js client] --> VA[Vercel Analytics]
  UI --> API[/api/chat/]
  API --> AI[Vercel AI SDK]
  AI -- OTel spans --> SE[Sentry AI Insights]
  AI -- LLM call --> OA[OpenAI]
  SE --> AL[Alerts: token spike · tool fail · p95 lat]

Step 1 — Sentry init

```ts // instrumentation.ts import * as Sentry from "@sentry/nextjs"; export function register() { Sentry.init({ dsn: process.env.SENTRY_DSN, tracesSampleRate: 1.0, profilesSampleRate: 0.1, integrations: [Sentry.openAIIntegration({ recordInputs: true, recordOutputs: false, // PII! })], }); } ```

Step 2 — Wrap a chat route

```ts // app/api/chat/route.ts import { streamText } from "ai"; import { openai } from "@ai-sdk/openai";

export async function POST(req: Request) { const { messages } = await req.json(); const result = streamText({ model: openai("gpt-4o-mini"), messages, experimental_telemetry: { isEnabled: true, functionId: "chat", metadata: { tenantId: "demo" } }, }); return result.toDataStreamResponse(); } ```

Step 3 — Vercel AI SDK → Sentry via OTel

```ts // instrumentation.ts (server) import { registerOTel } from "@vercel/otel"; import { SentrySpanProcessor, SentryPropagator } from "@sentry/opentelemetry"; registerOTel({ serviceName: "agent-app", spanProcessors: [new SentrySpanProcessor()], propagators: [new SentryPropagator()], }); ```

Step 4 — Vercel Web Analytics

```tsx // app/layout.tsx import { Analytics } from "@vercel/analytics/react"; export default function RootLayout({ children }: any) { return ({children}); } ```

Step 5 — Custom event for "first message"

```ts import { track } from "@vercel/analytics"; track("first_message_sent", { plan: "pro" }); ```

Step 6 — Sample at 100% with span budgets

Sentry's 2026 "AI traces at 100%" feature lets you keep every LLM span without sampling tools or routes. Enable per-project span budget in Settings → Performance.

Pitfalls

• PII leakage: recordInputs: true writes prompt text — redact or disable in HIPAA/GDPR contexts.
• Span explosions: Very long agent loops can produce 1000+ spans/run; set maxSpans: 200.
• Edge runtime: Some Sentry integrations require runtime = "nodejs".

How CallSphere does this in production

Explore a live demo and compare current plans to find the right fit for your business.

FAQ

Sentry pricing for AI? Same as regular tracing — 1M spans free, then ~$0.10/100K spans.

Replace LangSmith? For pure observability yes — but LangSmith has dataset + eval features Sentry lacks.

Privacy mode? Set recordInputs/Outputs: false and Sentry only stores metadata + token counts.

Seer (auto-RCA)? Sentry's AI debugging agent ships RCA at 94.5% accuracy on 2026 benchmarks.

Sources

• Sentry AI Observability - https://sentry.io/solutions/ai-observability/
• Sentry Agent Monitoring update - https://blog.sentry.io/sentrys-updated-agent-monitoring/
• Vercel AI SDK + Sentry OTel - https://sentry.io/cookbook/vercel-ai-sdk-otel-sentry/
• Sentry sample 100% AI traces - https://blog.sentry.io/sample-ai-traces-at-100-percent-without-sampling-everything/

Build AI Agent Observability with Sentry + Vercel Analytics (2026): production view

Build AI Agent Observability with Sentry + Vercel Analytics (2026) sits on top of a regional VPC and a cold-start problem you only see at 3am. If your voice stack lives in us-east-1 but your customer is calling from a Sydney mobile network, the round-trip time alone wrecks turn-taking. Multi-region routing, GPU residency, and warm pools become the difference between "natural" and "robotic" — and it's all infra, not the model.

Shipping the agent to production

Production AI agents live or die on three loops: evals, retries, and handoff state. CallSphere runs 37 agents across 6 verticals, each with its own eval suite — synthetic call transcripts replayed nightly with assertion checks on extracted entities (date, time, party size, insurance, address). Without that loop, prompt regressions ship silently and you only find out when bookings drop.

Structured tools beat free-form text every time. Our 90+ function tools all enforce JSON schemas validated server-side; if the model hallucinates an integer where a string is required, we retry with a corrective system message before falling back to a deterministic path. For long-running flows, we treat agent handoffs as a state machine — booking → confirmation → SMS — so context survives turn boundaries.

The Realtime API vs. async decision usually comes down to "is the user holding the phone right now?" If yes, Realtime; if no (callback queue, after-hours voicemail), async wins on cost-per-conversation, which we track per agent in 115+ database tables spanning all 6 verticals.

FAQ

Is this realistic for a small business, or is it enterprise-only? The IT Helpdesk product is built on ChromaDB for RAG over runbooks, Supabase for auth and storage, and 40+ data models covering tickets, assets, MSP clients, and escalation chains. For a topic like "Build AI Agent Observability with Sentry + Vercel Analytics (2026)", that means you're not starting from scratch — you're configuring an agent template that's already been hardened across thousands of conversations.

Which integrations have to be in place before launch? Day one is integration mapping (scheduler, CRM, messaging) and prompt tuning against your top 20 real call transcripts. Day two through five is shadow-mode running, where the agent transcribes and recommends but a human still answers, so you can compare side-by-side. Go-live is the moment your eval pass-rate clears your internal bar.

How do we measure whether it's actually working? The honest answer: it scales until your tool catalog gets stale. The agent is only as good as the integrations it can actually call, so the operational discipline is keeping schemas, webhooks, and fallback paths green. The platform handles the rest — observability, retries, multi-region routing — without your team owning the GPU layer.

Talk to us

Explore a live demo and compare current plans to find the right fit for your business.