What is agent observability?

Your agent makes dozens of decisions before it responds: which tool to call, whether to delegate, how much to trust a retrieval result. Agent observability is what lets you see those decisions after the fact. Not just the final API call, but every step that led to it: planning, tool invocations, handoffs, and what each one cost. The difference between knowing your agent failed and knowing why.

How is LumiqTrace different from LangSmith or Langfuse?

LangSmith and Langfuse are designed around LLM calls. LumiqTrace is designed around what happens around those calls: agent planning, tool decisions, delegation to other agents, and what all of it costs. Agents register themselves on first run, no setup required. Evals run automatically on every trace. You can query production data in plain English through LumiqPilot, and there's a hosted MCP server if you want to pull trace data into Claude or Cursor.

How long does setup take?

Under 5 minutes from signup to first trace in production. Run npm install @lumiqtrace/sdk or pip install lumiqtrace, then add two lines to your agent entry point: import the SDK and call lumiqtrace.init() with your API key. No config files, no architecture changes, no modifications to existing agent code. The first trace appears in your dashboard within seconds of the first agent run, with cost attribution, eval scores, and anomaly detection enabled by default.

What AI providers and frameworks does LumiqTrace support?

LumiqTrace supports OpenAI, Anthropic Claude, Google Gemini, Mistral, and OpenRouter on the model side. For agent frameworks: LangChain, LangGraph, CrewAI, Google ADK, AutoGen, and Vercel AI SDK. Both Python and TypeScript SDKs cover the full integration surface. LumiqTrace also supports native OpenTelemetry (OTel), so any OTel-compatible backend can receive trace data.

Is there a free tier?

Yes. The Free plan includes 10,000 traces per month, 14-day retention, 2 projects, and 1 seat. No credit card required. It includes full trace ingestion, cost attribution per agent run, manual evaluations, and pre-built guardrails. That's enough to fully instrument a production agent or run a complete evaluation before committing to a paid plan. When you need LLM-as-judge auto-evaluation or more traces, Solo starts at $39/month.

Can LumiqTrace trace multi-agent systems?

Yes. Multi-agent delegation is a first-class feature in LumiqTrace. Agent handoffs are captured as HANDOFF and CHAIN spans, and the dashboard renders the full delegation graph as an interactive swimlane timeline. You can see exactly which sub-agent was called, what it cost, how long it took, and whether it passed quality evaluation, all within a single trace view.

Does LumiqTrace replace tools like Datadog or New Relic for AI agents?

Different tools, different layer. Datadog tells you a request took 2.3 seconds. LumiqTrace tells you the agent called the wrong tool twice before getting there and spent $0.09 doing it. Most teams run both: their existing stack for infrastructure, LumiqTrace for what's happening inside the agent. They don't overlap much.

NewLumiqPilot: insights & actions in one chat

Agent observability for every production team.

LumiqTrace traces every AI agent decision, tool call, and handoff in production. Engineering teams debug faster, cut cost, and ship with confidence.

Free tier available·No credit card required·Setup under 5 minutes

LumiqTrace dashboard showing agent trace view with cost and latency metrics

<5 min

From signup to first trace in production

2 lines

To instrument any agent or model

10+

AI providers & frameworks auto-detected

AgentOps

Per-agent cost, latency & error attribution built-in

OTel

Native OpenTelemetry, any backend

Works with the AI stack your team already runs

OpenAI

Anthropic

LangChain

LangGraph

CrewAI

AutoGen

Google Gemini

Mistral

AWS Bedrock

OpenTelemetry

LumiqPilot

Understand your agents.
Then act on them.

Team & Scale plansCmd+J from anywhere

LumiqPilot reads your live trace data, metrics, and config to answer questions, then acts on them in the same conversation.

Deep data analysis

Ask "why did costs spike?" Pilot reads your live traces, surfaces the exact session, model, and deployment that caused it.

Instant action from insight

Continue the same conversation: create an alert, switch models, roll back a prompt, all without leaving Pilot.

Proactive auto-remediation

Pilot surfaces anomalies and cost opportunities before you ask. Define rules to auto-remediate incidents on Scale.

LumiqPilot · project: support-prod0 exchanges

Ask about your traces...

End-to-End Platform

One platform.
Every layer of your agent stack.

From the first planning step to the last tool call, every agent decision in one place. Two lines to instrument, nothing else to configure.

Tracing

Visualize agent delegation as a flow graph

See the full decision chain: agent handoffs, tool calls, planning spans, rendered as an interactive flame graph. Click any span for exact cost, latency, and token breakdown.

Multi-agent handoffs

Full per-hop timing and cost breakdown across every delegation.

LangChainCrewAIAutoGenLangGraph

Tool call spans

Every tool invocation with input, output, duration, and error state.

OpenAIClaudeGemini

Planning visibility

Inspect what the agent reasoned and decided before each action.

ReActCoTLangGraph

delegation · flame graphsuccess

Agent delegation flame graph showing multi-agent handoffs in LumiqTrace

Auto-Discovery

Every agent and tool, discovered automatically

Every agent that touches your SDK shows up in the registry on its first run: tools it uses, how often, and what it costs. Nothing to configure, nothing to register.

Zero-config discovery

Every agent catalogued on first run. No instrumentation beyond the SDK.

PythonTypeScriptOpenTelemetry

Tool & dependency mapping

See which tools each agent calls, at what frequency, and at what cost.

LangChainCustom toolsAny framework

Memory store detection

Identify agents reading from or writing to external memory stores.

PineconeWeaviatepgvector

agent registry · 7 agents discoveredauto-detected

LumiqTrace agent registry showing auto-discovered agents with usage and cost stats

Evaluations

LLM-as-judge on every trace, zero setup

Twelve eval templates (faithfulness, toxicity, coherence, task completion, and more) run automatically on every new trace. When a prompt change ships, you'll know within minutes if it broke something.

LLM-as-judge

Automated scoring by AI judge on every new trace. No setup required.

ClaudeGPT-4oGemini

12 built-in templates

Faithfulness, toxicity, relevance, coherence, and 8 more out of the box.

QualitySafetyPerformanceAgent

Custom scores via SDK

Merge your own eval results directly into the same dashboard.

span.setEvalScore()PythonTypeScript

evaluations · last 7d · SupportAgent1 regression

LumiqTrace evaluations dashboard showing LLM-as-judge scores and regression detection

Capabilities

Complete. Not retrofitted.

Cost AttributionExact spend per agent run, model, and prompt version.

Anomaly DetectionAuto-alerts on latency spikes, error surges, and cost drift.

Prompt VersioningTrack, compare, and roll back prompts across deployments.

Eval RunnerLLM-as-judge and custom criteria on every trace, in bulk.

Agent RegistryAuto-discovered agents with delegation graphs and metadata.

Real-time AlertsSlack and webhook notifications on any threshold you set.

Setup

Under 5 minutes,
two lines of code.

Install

One package, two runtimes

Python and TypeScript both supported. No forking, no vendor lock-in, no architecture changes required.

terminal

$ npm install @lumiqtrace/sdk

# or for Python

$ pip install lumiqtrace

✓ installed successfully

Use Cases

Built for every
AI team workflow.

One support bot or a hundred agents: the trace structure is the same.

LangChain & LangGraph

Trace every chain node, retrieval step, and prompt template with full token breakdown per hop.

RAG pipelinesChain tracingRetrieval spans

CrewAI & AutoGen

Per-role cost and latency across every multi-agent delegation. See exactly which agent burned your budget.

Multi-agentRole attributionHandoff timing

Customer Support AI

SLA-aware error tracking, escalation pattern detection, and per-session quality scoring.

Error rateEscalationsQuality scoring

FinOps & Cost Control

Per-model spend attribution, overage alerts, and budget guardrails before a session goes rogue.

Spend alertsModel comparisonBudget guardrails

DevOps AI Pipelines

Deployment-correlated anomaly detection. Know within seconds if your last push broke agent behavior.

Deploy correlationAnomaly detectionCI/CD

Eval & Regression

Auto LLM-as-judge scoring on every trace. Catch prompt regressions the moment a change ships.

LLM-as-judgeRegression alerts12 built-in templates

Outcomes

Every AI decision,
traced and accountable.

Everything that tells you if your agents are healthy: what they cost, where they fail, how long they take, and whether the output is any good. One dashboard, updating as runs happen.

LumiqTrace evaluation dashboard showing eval scores, cost metrics, and agent performance

Compare

Built for agent observability.
Not retrofitted.

Capability comparison: LumiqTrace vs Helicone, LangSmith, and Langfuse
	LumiqTrace	Helicone	LangSmith	Langfuse
Setup time	2 lines, <5 min	Minutes	Minutes	Minutes
Cost tracking
Trace flame graph		Not available
Agent auto-discovery		Not available	Not available	Not available
Multi-agent delegation		Not available	Limited	Limited
AI Cost Optimizer	✓ Exclusive	Not available	Not available	Not available
AI Anomaly Detection	✓ Exclusive	Not available	Not available	Not available
Natural Language Query	✓ Exclusive	Not available	Not available	Not available
Auto Root Cause Analysis	✓ Exclusive	Not available	Not available	Not available
MCP server	✓ Exclusive	Not available	Not available	Not available
Evaluation templates	12 built-in	Not available	Custom only	Custom only
Free tier	10K traces/mo	10K/mo	Limited	Limited
Starting price	$39 / month	$20	$39	$29

MCP Server

Query your production data from Claude or Cursor.

LumiqTrace provides a hosted MCP server with 9 tools. Connect Claude Desktop, Cursor, or any MCP-compatible client and query traces, run root cause analysis, and ask natural language questions about your production data.

// claude_desktop_config.json
{
  "mcpServers": {
    "lumiqtrace": {
      "url": "https://api.lumiqtrace.com/v1/mcp",
      "headers": { "Authorization": "Bearer lqtp_..." }
    }
  }
}

list_projects

All projects your API key can access

get_project_overview

Event count, errors, avg latency summary

query_traces

Filter by model, status, time range, limit

get_trace

Full span detail for any trace ID

get_slow_traces

Slowest traces in any time window

get_metrics

Cost, latency, tokens by model or day

get_errors

Error breakdown by code and model

natural_language_query

Plain English to ClickHouse to results

root_cause_analysis

Automated RCA on any failed trace ID

Pricing

Transparent pricing.

Start free. Scale as your agents grow.

Free

Start tracing your agents instantly. 10,000 traces a month with zero commitment.

Free Plan

Get started with

14-day retention
2 projects · 1 seat
Trace ingestion (SDK + OTel)
Cost attribution per trace
Manual evaluations
Pre-built guardrail rules

Solo

For individual developers shipping production agents. 100K traces a month included.

$39/mo

Everything in Free

30-day retention
10 projects · 1 seat
LLM-as-judge auto-eval
Custom eval criteria
Prompt versioning + playground
Slack / webhook notifications

Pro

Full platform for teams shipping agents at scale. 500K traces a month with overage.

$149/mo

Everything in Solo

90-day retention
Unlimited projects · 10 seats
LumiqPilot (200 queries/mo)
Custom guardrails + enforcement
Bulk eval runs + history
A/B prompt testing + AI optimization
Simulations + anomaly detection
AI incident correlation

Team

Advanced controls for growing engineering teams. 2M traces a month with SSO and SLA.

$299/mo

Everything in Pro

180-day retention
Unlimited projects · 15 seats
LumiqPilot (1,000 queries/mo)
Scheduled simulations
SSO (SAML/OIDC)
PagerDuty integration

Enterprise

Scale

Custom pricing for large teams. 10M+ traces, self-hosted option, dedicated SLA, and unlimited seats.

10M+ traces / month
Unlimited seats
LumiqPilot unlimited
BYOK (Bring Your Own Keys)
Self-hosted deployment option
365-day retention
Dedicated SLA + support
Custom integrations

Pricing Calculator

Estimate your monthly cost

Plan

Monthly traces500,000

10K100K500K2M5M+

Seats

Pro plan

Base

$149

Trace overage

—

Extra seats

—

Total / Month

$149

Item	Details	Cost
Base plan	Pro	$149.00
Included traces	500,000 of 500,000 used	$0.00
Trace overage	None (within included limit)	—
Included seats	3 of 10 used	$0.00
Extra seats	None (7 seats still available)	—
Total		$149/mo

Your agents are running.
Do you know what they're doing?

Join the waitlist. Be first to know when we launch.

Free tier available

Under 5 min setup

No credit card

FAQ