Agno tracing vs. LangSmith

Checked against the Agno and LangChain documentation on 22 October 2026. LangSmith pricing and retention change often; re-check both before you rely on the figures below.

Agno tracing and LangSmith both trace AI agents, but they store traces in different places. AgentOS(tracing=True) writes OpenTelemetry spans to your own database with no per-trace cost. LangSmith is LangChain's hosted platform, with deeper eval tooling, billed per trace and capped at 180 days. Choose LangSmith for eval breadth. Choose Agno to keep traces in your infrastructure. Running both is also a supported option.

Does Agno have built-in observability?

Yes, and it is one switch. Install the AgentOS extras and set tracing=True:

from agno.os import AgentOS
 
agent_os = AgentOS(
    agents=[agent],
    db=db,
    tracing=True,
)

That instruments agent, team and workflow operations. Each run produces spans for model calls, tool executions, team coordination and workflow steps. AgentOS writes the aggregate trace to agno_traces and the individual spans to agno_spans.

Agents built with other frameworks are covered too, which matters if you have not standardised on one. AgentOS serves agents built with the Claude Agent SDK and Codex as first-class harnesses, and integrates with LangGraph, DSPy and Antigravity. For those agents it records runs, tool calls with their arguments and results, and the token usage their native SDK reports, in the same database as everything else.

Be precise about the depth, though, because it is not yet equal. Native Agno agents get the full OpenInference span tree. External harnesses get run records, tool history and metrics; span-level OpenInference tracing for them is an upstream follow-up rather than a shipped feature. If your evaluation hinges on identical span trees across frameworks, test it before you commit.

Where do your traces live?

This is the question that usually decides it.

Agno writes to a database you own. PostgresDb creates its tables in the ai schema by default, so the spans are queryable with ordinary SQL:

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

Because traces are write-heavy and have a different retention profile from session data, you can point AgentOS at a separate database and leave your agent data alone:

agent_db = PostgresDb(db_url="postgresql+psycopg://primary/...")
trace_db = PostgresDb(db_url="postgresql+psycopg://traces/...")
 
agent = Agent(name="Research Agent", model=OpenAIResponses(id="gpt-5.2"), db=agent_db)
 
agent_os = AgentOS(agents=[agent], db=trace_db, tracing=True)

LangSmith stores traces in its own cloud, in the region you pick at signup. Self-hosted and hybrid deployment exist, but as Enterprise options rather than something you can turn on from the Developer or Plus tiers.

One claim worth not making: that no data leaves your infrastructure. Tracing does not change where models and tools send data, and your agent still calls whatever external providers it was going to call. What tracing decides is where the trace record lands. Trace attributes can hold prompts, tool arguments and model output, so give that table the same access and retention controls as any other sensitive data.

What does each cost at volume?

Agno has no per-trace, storage or retention fee. The cost is your own database.

LangSmith includes an allowance and meters beyond it. As of today, Developer is $0 per seat with up to 5,000 base traces a month, and Plus is $39 per seat per month with up to 10,000. Past the allowance it is pay-as-you-go: billing is denominated in LangChain Standard Units at $1.00 per LSU, and the pricing calculator rates an additional trace at 0.005 LSU.

Work that out for your own volume before choosing. At a few thousand traces a month the included allowance covers it and the question is irrelevant. At a few million it is the whole question, and it compounds with the retention tier, since extended traces cost more than base ones and therefore reduce how many you get for the same spend.

How do evals and debugging compare?

LangSmith is genuinely stronger here, and it is worth saying so plainly. It ships online and offline evals, dataset collection, annotation queues for human feedback, monitoring, alerts and rules, a prompt playground and its Engine issue detection. That is a mature product built specifically for this, and nothing in Agno matches its breadth.

Agno's evals are a smaller, code-first set that runs where your agents run: AccuracyEval, AgentAsJudgeEval, ReliabilityEval and PerformanceEval, with results stored in your database alongside the traces. They fit a workflow where evals are suites you gate CI on rather than dashboards a team reviews. If you want the reasoning behind treating them that way, agent evals are the new unit tests makes the case.

So if team eval workflows are the thing you are buying, that points at LangSmith. If trace storage is the thing you are buying, it points the other way.

Can I use Agno with LangSmith?

Yes, and for a lot of teams this is the right answer rather than a compromise.

Agno emits OpenTelemetry, and LangSmith ingests OTLP, so you can configure an exporter pointed at LangSmith and keep the database writes as well. The standard OpenTelemetry environment variables are what carry it:

OTEL_EXPORTER_OTLP_ENDPOINT=https://api.smith.langchain.com/otel
OTEL_EXPORTER_OTLP_HEADERS="x-api-key=...,Langsmith-Project=..."

One setup detail to know: tracing configuration is process-wide. If a real OpenTelemetry tracer provider is already installed, Agno's setup returns without replacing it or adding its own database exporter. When you are combining integrations, configure the provider and its exporters together rather than expecting both paths to appear on their own.

The same mechanism points anywhere else. Langfuse, Arize, Logfire, MLflow, The Context Company and any other OpenTelemetry endpoint are all configurable destinations.

What are the best open-source options for agent observability?

If you want traces without buying an observability product, the practical choice is a runtime that emits OpenTelemetry and lets you choose the destination.

Agno is one: Apache 2.0, traces in your database, OpenInference conventions, and exporters to the tools above. Because the format is standard rather than proprietary, the decision is reversible. If you outgrow SQL over agno_spans, you point an exporter somewhere else without re-instrumenting anything. For high trace volume there is also a ClickHouse adapter when Postgres stops being the right shape.

That reversibility is the real argument. A proprietary trace format is a decision you make once; an OpenTelemetry one is a decision you can revisit.

Which should you use?

Choose LangSmith if you want a mature standalone platform that takes traces from any app without changing how you run it, if team eval workflows matter more than raw trace storage, or if you are on LangChain or LangGraph where the setup is native.

Choose Agno tracing if traces have to stay in your infrastructure, if you want no per-trace fee and no fixed retention window, if you want to query spans with SQL, or if your agents already run on more than one framework and you want their runs in one database.

Choose both if you want the eval tooling and the owned copy. The OTLP path makes that a configuration choice rather than an architectural one.

Sources

• Agent observability — tracing setup, tables, destination rules, exporters
• Agent harnesses and inspecting runs — framework coverage and what is recorded
• Agno evals — the four eval classes
• LangSmith pricing — plans, included traces, LSU metering
• LangSmith billing and retention — base and extended trace tiers
• LangSmith self-hosting and OpenTelemetry ingestion