+ P Observe for LiveKit agents
Capture every LiveKit AgentSession as it actually runs — the same session lifecycle and track events the SDK uses to orchestrate a voice call, not a side channel bolted onto the audio pipeline.
Prefactor observes your LiveKit agents in real time — every LLM call, tool invocation, and custom span captured as structured trace data the moment it happens, with cost attributed per call and a tamper-evident audit trail of every run.
How to add observe to LiveKit
Install the SDK
Add prefactor-core to your environment.
Register & create spans
Register the agent instance and record spans around your LiveKit run.
Spans flow to Prefactor
Structured trace data lands in Prefactor as your agent runs.
# pip install prefactor-core
import os
from prefactor_core import PrefactorCoreClient, PrefactorCoreConfig
from prefactor_http import HttpClientConfig
config = PrefactorCoreConfig(
http_config=HttpClientConfig(
api_url="https://app.prefactorai.com",
api_token=os.environ["PREFACTOR_API_TOKEN"],
)
)
client = PrefactorCoreClient(config)
await client.initialize()
# then instrument your LiveKit run with spans — see docs.prefactor.aiShown with the Prefactor SDK — a first-class, working integration today.
How the LiveKit integration actually works
- AgentSession is LiveKit's own orchestrator — it collects user input, runs the voice pipeline, invokes the LLM, and sends output back; Prefactor spans attach at the same session boundary, not a separate hook layered on top.
- RoomIO — the utility LiveKit creates automatically when a session starts — bridges the AgentSession to the room's tracks and the linked participant; that's the same boundary Prefactor's spans use to capture each turn.
- A native LiveKit package (prefactor-livekit) is available — verify its snippet against docs.prefactor.ai before switching this page to it.
What Prefactor captures for LiveKit agents
LLM calls
Model, prompt, completion, and token usage recorded for every call — not batched, not sampled after the fact.
Tool invocations
Arguments, results, and errors for each tool the agent calls.
Agent spans
The run captured as nested spans you can inspect step by step — plus custom spans for whatever's specific to your own domain.
Cost per call
Token usage rolled up into cost, attributed to the agent, team, and task that spent it — the same span data, not a separate metering system.
Immutable audit trail
Every span and run written once, tamper-evident, full-text searchable, and exportable for compliance review.
Trace anything — not just LLM calls
The SDK captures LLM, tool, and agent spans automatically. With withSpan you wrap any operation in your own span type — an API call, a database query, a quality check, a business action — each with its own payload and schema. It all flows into the same Observe, Evaluate, and cost views.
import { withSpan } from "@prefactor/core";
// Wrap ANY operation in a span you define — an API call, a quality
// check, a business action — with its own spanType, inputs and schema
await withSpan(
{
name: "research competitor",
spanType: "research_competitor",
inputs: { competitor },
},
async () => {
const results = await search(competitor); // your tool / API calls
return summarize(results); // captured as one span
},
);Nest spans to capture business-level actions, and start with permissive schemas you tighten over time. Instrumentation strategy →
An example run, span by span
Illustrative — a single LiveKit run as nested spans.
Illustrative example.
Manual logging vs DIY vs Prefactor
| Capability | Manual | DIY OpenTelemetry | Prefactor |
|---|---|---|---|
| LLM / tool / agent spans | Hand-rolled | ✓ build it | ✓ via the SDK |
| Token usage captured per call | — | Build it | ✓ |
| Configurable capture & sampling | — | Partial | ✓ |
| Hosted Admin UI (agents, instances) | — | — | ✓ |
| Risk profiles & audit trail | — | — | ✓ |
LiveKit observe — FAQ
What does Prefactor capture for LiveKit?+
LLM calls, tool invocations, and agent spans — with inputs, outputs, and token usage — sent to the Prefactor API as structured trace data the moment they happen, not reconstructed from a log afterward.
Is Prefactor in my LiveKit request path?+
No — the SDK instruments in-process and sends spans asynchronously. Your requests go straight to your model provider; Prefactor observes what happened alongside it.
How does cost tracking work for LiveKit?+
Cost is derived from the token usage captured on each LLM span and rolled up by agent, team, and task — a view over the same trace data, not a separate metering system, so a cost spike traces back to the run that caused it.
Can audit records for LiveKit runs be edited or deleted?+
No. Instances and spans are immutable once written, giving reviewers a real-time, queryable record of exactly what every agent did — the evidence a compliance review or an incident investigation actually needs.
Do I need a dedicated package for LiveKit?+
LiveKit has a native package (prefactor-livekit); you can also instrument it today with the framework-agnostic prefactor-core SDK.
What does Prefactor capture from LiveKit?+
Prefactor records voice-session turns, STT and TTS steps, tool calls and LLM calls as structured, timestamped spans — so every LiveKit run is captured as trace data you can reconstruct, search and export end to end.
Does Prefactor add latency or change how LiveKit runs?+
No. Observability capture is designed to stay off your agent's critical path, so it doesn't alter your LiveKit logic or your users' responses. The only part that acts inline is the optional runtime guardrails you enable per agent — by design, so a high-risk or low-confidence action can be held for human approval before it executes.
Can I evaluate agents built with LiveKit and catch regressions?+
Yes. Once runs are captured, eval suites score quality and groundedness on real traffic, drift detection flags behaviour changes after deployment, and versioned eval history catches regressions before they ship — the observe → evaluate → improve loop applied to your LiveKit agents.
Keep going
Observe for other frameworks
LangChain →CrewAI →LangGraph →OpenAI Agents SDK →Claude Agent SDK →Microsoft AutoGen →See it on your LiveKit agents
Book a 15-minute setup and our team gets you observe in production.