Zespan is an AI agent observability and engineering platform. It traces every agent decision, tool call, handoff, and delegation in production. It also provides prompt versioning, built-in LLM-as-judge evaluations, guardrails, cost optimization, and an AI ops assistant called ZespanPilot.

How do I instrument my AI agent with Zespan?

Zespan requires 2 lines of code. Import zespan and call zespan.init({ apiKey: process.env.LT_KEY }). This auto-patches OpenAI, Anthropic, Gemini, Bedrock, and Mistral. For framework-level tracing, add one handler: ZespanCallbackHandler for LangChain, ZespanCrewAIListener for CrewAI, or ZespanADKHandler for Google ADK.

Does Zespan support prompt versioning?

Yes. Zespan includes prompt management with versioning, a playground for iteration, and A/B testing to compare prompt versions against each other in production.

What evaluations does Zespan support?

Zespan ships 12 built-in LLM-as-judge evaluation templates including faithfulness, relevance, toxicity, groundedness, and more. Evaluations run automatically on every trace with no custom scoring functions required.

How does Zespan compare to Langfuse?

Zespan is agent-native: every span carries agent identity, delegations are first-class trace events, and an agent map is built automatically. Langfuse was built for LLM pipelines and extended to agents later. Zespan also ships 12 built-in eval templates (Langfuse has none), includes an AI cost optimizer, and ZespanPilot for AI ops. Langfuse has open-source self-hosting; Zespan does not.

What is the free tier for Zespan?

The free tier includes 10,000 traces per month, 14-day retention, 2 projects, and 1 seat. No credit card required.

PydanticAI Integration

Pass getPydanticAIConfig() to your agent's instrument parameter. Full observability for PydanticAI agents with zero restructuring.

PydanticAI is a Python agent framework built by the Pydantic team, providing type-safe structured outputs, dependency injection, and multi-model support.

zespan.com — pydanticai trace

Zespan trace showing a PydanticAI agent run with tool calls and structured output

Getting Started

Install the SDK

Install the Zespan Python SDK alongside pydantic-ai.

bash

pip install zespan pydantic-ai

Add the instrumentation config

Call get_pydantic_ai_config() and pass the result to your agent's instrument parameter. All LLM calls, tool uses, and dependency injections are traced.

python

from zespan.sdk import get_pydantic_ai_config
from pydantic_ai import Agent

config = get_pydantic_ai_config(api_key="your-api-key")

agent = Agent(
    'openai:gpt-4o',
    instrument=config,
    system_prompt='You are a helpful assistant.',
)

result = await agent.run('What is the capital of France?')

View traces in Zespan

Open Trace Explorer. PydanticAI agent runs appear with the full execution — LLM calls, tool invocations, and structured output parsing.

What's captured automatically

Native PydanticAI integration: instrument parameter format matches exactly
All PydanticAI model providers: OpenAI, Anthropic, Gemini, Groq, Ollama
Tool calls: PydanticAI tool invocations as child spans with arguments and results
Structured output: raw model output and Pydantic-parsed result both captured
Dependency injection: context visible in traces so you understand how deps shape behavior

FAQ

Does this work with all PydanticAI model providers?

Yes. get_pydantic_ai_config() returns a provider-agnostic config. OpenAI, Anthropic, Gemini, Groq, and Ollama models are all traced.

Can I use this with PydanticAI's structured output mode?

Yes. Both the raw model output and the Pydantic-parsed result are captured in the trace, so you can see schema validation failures as well as successful structured responses.

Start for free — 10K traces/month, no card needed

PydanticAI integration works on all plans including the free tier.

Get started free →Get a demo

← All integrations