Agent Observability

Store traces, run history, and audit logs in your own database with the built-in tracing provider.

AgentOS comes with a built-in tracing provider that routes every run to your database. There is no external observability SaaS to sign up for, no API key to manage, and no data egress. Your traces live in agno_traces and agno_spans in the same db you already use for sessions and memory.

from agno.os import AgentOS

agent_os = AgentOS(
    agents=[agent],
    db=db,
    tracing=True,
)

Every run produces a trace tree: spans for the LLM call, each tool, team delegation, and workflow step. Tracing is built on OpenTelemetry and instruments your agents with zero code changes.

Your data never leaves your db

This is the difference between AgentOS tracing and hosted observability platforms.

	AgentOS tracing	Hosted observability SaaS
Where traces live	Your database	Their servers
Data egress	None	Every prompt, tool call, and response leaves your network
Vendor dependency	None	Your observability stops if they go down or you stop paying
Cost model	Your existing database	Per-seat or per-event billing
Querying	Direct SQL on your tables	Their API and UI only

Prompts, tool arguments, and model outputs often contain customer PII, internal data, and proprietary logic. With AgentOS tracing, none of it crosses your network boundary. You own the data, you control retention, and you can query it with the database tools you already run.

What gets captured

Span	Attributes
Run	agent_id, user_id, session_id, latency, status
LLM call	Model, prompt tokens, completion tokens, invocation parameters, tool calls
Tool	Tool name, arguments, result, duration, error (if any)
Team delegation	Team name, member runs as nested spans
Workflow step	Step name, step type, input/output

Traces follow OpenInference semantic conventions, so you can query them directly:

-- Top 10 slowest span types by average duration
SELECT
    name,
    AVG(duration_ms) AS avg_ms,
    COUNT(*) AS calls
FROM agno_spans
GROUP BY name
ORDER BY avg_ms DESC
LIMIT 10;

In the AgentOS UI

The control plane renders the same traces visually. Click a run to see the full tree: LLM hops, tool calls with their inputs and outputs, and sub-agent traces. Filter by user, session, or time range.

Multi-database tracing

Traces are high-volume and write-heavy, with a different cost profile, retention, and access pattern than sessions. For production, route them to a dedicated database by pointing the AgentOS db at it:

from agno.agent import Agent
from agno.db.postgres import PostgresDb
from agno.os import AgentOS

# Each agent keeps its own database
agent_db = PostgresDb(db_url="postgresql://primary/...")

# Dedicated database for traces
trace_db = PostgresDb(db_url="postgresql://traces/...")

agent = Agent(name="Research Agent", model=..., db=agent_db)

agent_os = AgentOS(
    agents=[agent],
    db=trace_db,   # All traces are written here
    tracing=True,
)

The AgentOS db is where traces land. Keeping it separate isolates trace write volume from your agent data and gives you independent retention and scaling.

See Multi-DB tracing for the setup_tracing() variant with batch tuning.

External providers

If you already run an observability platform, AgentOS can export to it instead of (or alongside) your database. Add an OpenTelemetry exporter to send traces to Langfuse, Langsmith, Arize, Logfire, MLflow, or any OTel endpoint.

See the Observability section: Langfuse, Langsmith, Arize, Logfire, MLflow.

Developer Resources

• Tracing overview
• Tracing in AgentOS
• Query traces from your database