Send a trace, read the verdict

Quickstart

1. Sign up at app.spanview.dev.
2. Create an API key under API keys. It is shown once — copy it.
3. Point OpenTelemetry at spanview:

   export OTEL_EXPORTER_OTLP_ENDPOINT=https://app.spanview.dev
   export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <your API key>"

4. Install the exporter and your framework's instrumentor:

   pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-http
   
   # then one of:
   pip install openinference-instrumentation-langchain          # LangChain / LangGraph
   pip install openinference-instrumentation-openai-agents      # OpenAI Agents SDK
   pip install openinference-instrumentation-claude-agent-sdk   # Claude Agent SDK

5. Add this before your agent runs (LangGraph shown — swap the instrumentor for your framework):

   from opentelemetry import trace
   from opentelemetry.sdk.resources import Resource
   from opentelemetry.sdk.trace import TracerProvider
   from opentelemetry.sdk.trace.export import BatchSpanProcessor
   from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
   from openinference.instrumentation.langchain import LangChainInstrumentor
   
   provider = TracerProvider(resource=Resource.create({"service.name": "my-agent"}))
   provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter()))
   trace.set_tracer_provider(provider)
   LangChainInstrumentor().instrument()
   
   # ... run your agent ...
   provider.force_flush()   # short scripts: flush before the process exits

   OpenAI Agents SDK: from openinference.instrumentation.openai_agents import OpenAIAgentsInstrumentor. Claude Agent SDK: from openinference.instrumentation.claude_agent_sdk import ClaudeAgentSDKInstrumentor. service.name becomes the run's project in spanview.

6. Run your agent. The run appears in the app within seconds.

After a run

• Within seconds — the run and every step show up in the app as they arrive.
• When the run goes quiet for 60 seconds, it is queued for evaluation. Spans keep arriving while an agent works, so spanview waits until the trace is complete.
• Within about 5 minutes of that, the verdict appears. Evaluation itself takes seconds to about half a minute, even for runs with hundreds of steps.
• To evaluate a run again, use POST /api/v1/runs/{id}/evaluate (see HTTP API).

Reading a verdict

Each evaluated run gets a verdict and a note on every step.

Step notes. Open a run and click any step to see its input, output, latency, tokens and the evaluator's note: a severity, a category and one or two sentences of evidence quoted from the step. Wrapper spans (graph nodes, agent turns) are shown but not graded — their child steps are.

Categories the evaluator uses:

tool_call_failed tool_output_swallowed_error tool_output_invalid_json tool_arg_type_mismatch hallucinated_tool_name infinite_loop runaway_recursion silent_retry_storm premature_termination wrong_handoff unverified_claim ungrounded_answer stale_data retrieval_empty retrieval_irrelevant retrieval_duplicate_results context_window_overflow prompt_template_corruption prompt_injection_in_tool_output system_prompt_drift model_refusal output_schema_violation truncated_output latency_outlier cost_outlier token_explosion

Comparing runs

Open a run and use Compare to diff it against another run — a passing run against a failing one, or before and after a prompt change. spanview lines up the steps and highlights what changed: inputs, outputs, tool calls, token counts and the step sequence. Also available as POST /api/v1/compare.

Instrumentation

spanview accepts standard OTLP over HTTP (protobuf or JSON) and reads the three common LLM span conventions:

• OpenInference — LangChain / LangGraph, OpenAI Agents SDK, Claude Agent SDK instrumentors. This is what spanview is tested against end to end.
• OpenTelemetry GenAI semantic conventions.
• OpenLLMetry (Traceloop).

Any other framework works if you can export OTLP traces from it — custom spans still show up; LLM-specific fields are read when they follow one of the conventions above.

HTTP API

Base URL https://app.spanview.dev. Authenticate with your API key, either Authorization: Bearer <key> or X-API-Key: <key>.

curl -s https://app.spanview.dev/api/v1/runs/<run id>/diagnosis \
  -H "Authorization: Bearer $SPANVIEW_API_KEY"

Data & privacy

• Your traces stay in your account. Every run, step and verdict belongs to your organization; other accounts can't see or query them.
• Secrets are redacted on arrival, before anything is stored: values that look like API keys or tokens (OpenAI, Anthropic, Google, GitHub, AWS keys, bearer tokens, JWTs), and the whole value of any attribute whose name contains password, secret, token, api_key or authorization.
• The evaluator runs on Claude Haiku through OpenRouter, routed only to Amazon Bedrock or Google Cloud Vertex AI, with zero data retention enforced: the model provider does not store your prompts or outputs, and nothing is used for training. OpenRouter's prompt logging is off.
• Only what the evaluator needs is sent to it: each step's input, output and metadata, with repeated conversation history removed.

Limits

• 10 MB per request. OTLP exporters send traces in small batches, so this only affects unusually large single spans.
• Leave OTLP compression off (the default). gzip-compressed exports aren't accepted yet.

Support

Email team@spanview.dev.

Coming soon

• CLI — list runs, show a verdict, compare runs from the terminal.
• MCP server — let Claude Code, Claude Desktop or any MCP client read your runs and verdicts.
• Self-hosting — run spanview on your own infrastructure.