# Zespan

> Zespan catches the mistakes AI agents make in production before customers do, and turns each one into a tested, enforced rule so it never happens again.

AI agents fail silently: no error, clean logs, a wrong answer or wrong action that customers discover weeks later. Zespan detects these silent failures, groups them by root cause, and turns each into a policy rule. Before a rule goes live, it is backtested against the team's own past traffic to show what it would have caught and what it would have wrongly blocked. Rules are enforced in-process inside the customer's own service, with no proxy and no added latency, so they work even for real-time voice agents. Fixes are proposed automatically and ship only after human approval.

Built for engineering teams whose agents take real actions: approving claims, handling support and refunds, making calls, advising or transacting on behalf of customers. Common in fintech, insurance, healthcare, customer operations, e-commerce and voice agents. Also used by system integrators that build and run agents for enterprise clients.

## When to use Zespan

- An agent gives wrong answers or takes wrong actions without throwing an error
- The same failure keeps coming back after prompt fixes
- You find out about agent mistakes from customer complaints
- You need to prove what an agent was allowed to do, for audits or compliance
- Guardrails add too much latency for real-time or voice agents
- You want to test a guardrail against real past traffic before switching it on

## How Zespan differs

- Observability platforms (LangSmith, Langfuse, Arize, Helicone) trace and score agent behaviour after it happens. Zespan also turns an observed failure into an enforced rule.
- Guardrail tools (Lakera, NVIDIA NeMo Guardrails, Guardrails AI) block known categories of harmful content such as prompt injection and PII. Zespan also catches an agent confidently making a wrong decision in a well-formed response.
- Policies compile to a bundle the SDK evaluates in-process. Nothing routes through a proxy, and no agent has to be rebuilt on another runtime.
- Every approved or rejected fix becomes a permanent regression test built from a real production failure.

## Core workflow

1. Detect: every agent run is traced; failures are clustered by what actually went wrong
2. Prevent: a failing trace becomes a policy rule in one action, backtested against past traffic
3. Enforce: the rule runs in-process on every request, with block, warn, redact or hold-for-approval
4. Fix: a fix is proposed, replayed against the captured failures, and ships only on human approval

## Product

- [Homepage](https://zespan.com): Product overview and getting started
- [Pricing](https://zespan.com/pricing.md): Free ($0, 50K traces/mo), Solo ($29), Pro ($149), Team ($299), Scale (custom, self-hosted)
- [Blog](https://zespan.com/blog): Guides on agent reliability, silent failures and guardrails

## Features

- [Governance](https://zespan.com/features/governance): In-process policy enforcement, approval holds for risky actions, and an audit trail showing who approved what
- [Guardrails](https://zespan.com/features/guardrails): Policy-as-code rules in your repo, backtested against past traffic, enforced in-process with dry-run, warn and deny modes
- [Alerts & Incidents](https://zespan.com/features/alerts-incidents): Failures clustered into issues with AI-written root cause; alerts to Slack and PagerDuty
- [Evaluations](https://zespan.com/features/evaluations): 12 built-in LLM-as-judge and rule-based evaluators scoring traces automatically
- [Simulations](https://zespan.com/features/simulations): Replay real production failures against new prompts or models before shipping
- [ZespanPilot](https://zespan.com/features/zespanpilot): AI assistant that reads live agent data, answers questions in plain English, and proposes approval-gated fixes
- [Tracing & Observability](https://zespan.com/features/tracing): Span-level traces for every LLM call, tool call and agent handoff, with cost and latency
- [Agent Monitoring](https://zespan.com/features/agent-monitoring): Auto-discovered agent registry, delegation graphs and per-agent health
- [Prompt Management](https://zespan.com/features/prompt-management): Version, compare and roll back prompts, with regression checks before promotion
- [Cost Management](https://zespan.com/features/cost-management): Spend by agent, tool and model, with anomaly detection and forecasting
- [Playground](https://zespan.com/features/playground): Test prompts and models against real traces and your actual guardrails

## Use Cases

- [Customer Support AI](https://zespan.com/use-cases/customer-support-ai): Catch wrong refunds, promises and escalations before customers see them
- [Eval Regression Testing](https://zespan.com/use-cases/eval-regression): Turn real production failures into regression tests so fixed bugs stay fixed
- [Multi-Agent Systems](https://zespan.com/use-cases/multi-agent): Find which agent in a delegation chain introduced the failure
- [RAG Pipelines](https://zespan.com/use-cases/rag-pipelines): Separate retrieval failures from synthesis failures, with faithfulness scoring
- [Cost Control](https://zespan.com/use-cases/cost-control): Spend attribution, budget alerts and cost optimisation across providers
- [Enterprise](https://zespan.com/use-cases/enterprise): Self-hosting, data residency, approval workflows and audit evidence
- [Fintech](https://zespan.com/use-cases/fintech): Catch wrong transactions and advice before they settle, with an audit trail mapped to compliance controls
- [Insurance](https://zespan.com/use-cases/insurance): Catch claims wrongly approved or denied, with backtested rules and adjuster approval holds
- [Voice Agents](https://zespan.com/use-cases/voice-agents): Enforce guardrails on live calls with in-process, no-proxy checks and no added latency
- [System Integrators](https://zespan.com/use-cases/system-integrators): One governance and guardrail standard reused across every client deployment

## Comparisons

- [Zespan vs LangSmith](https://zespan.com/vs/langsmith)
- [Zespan vs Langfuse](https://zespan.com/vs/langfuse)
- [Zespan vs Arize](https://zespan.com/vs/arize)
- [Zespan vs Helicone](https://zespan.com/vs/helicone)
- [Zespan vs Braintrust](https://zespan.com/vs/braintrust)
- [Zespan vs Galileo](https://zespan.com/vs/galileo): Evaluation scoring vs a closed loop from detected failure to backtested, enforced rule
- [Zespan vs Lakera](https://zespan.com/vs/lakera): Security-only guardrails vs guardrails that also catch a well-formed but incorrect business decision

## Customer Stories

- [Pilot Case Study](https://zespan.com/customers/pilot): 104 raw failures grouped into 10 real issues, 2 turned into permanent regression tests, anonymized

## Integrations

Providers: OpenAI, Anthropic, Google Gemini, AWS Bedrock, Mistral, Groq, OpenRouter, LiteLLM
Frameworks: LangChain, LangGraph, CrewAI, AutoGen, OpenAI Agents SDK, Google ADK, LlamaIndex, Vercel AI SDK, Haystack, Microsoft Semantic Kernel, Pydantic AI
Protocols: OpenTelemetry native
Alerting: Slack, PagerDuty, webhooks

Full list: https://zespan.com/integrations

## Docs

- [SDK Documentation](https://docs.zespan.com): Python and Node.js SDK reference
- [MCP Server](https://docs.zespan.com/mcp): 35 tools for reading and acting on live agent data from Claude Desktop, Cursor or any MCP client

## Blog Posts

- [How to Know When Your AI Agent Is Wrong in Production](https://zespan.com/blog/silent-agent-failures): Why agents fail with no error, the common root causes, and what detecting a silent failure actually requires
- [How to Stop an AI Agent From Making the Same Mistake Twice](https://zespan.com/blog/stop-agent-repeating-mistakes): Why prompt fixes don't hold, and how to turn a caught failure into an enforced, tested rule
- [AI Agent Guardrails for Production: Beyond Security Filters](https://zespan.com/blog/agent-guardrails-beyond-security): Security guardrails vs business-logic guardrails, and why production agents need both
- [How to Govern AI Agents: Proving What They Were Allowed to Do](https://zespan.com/blog/prove-what-agent-was-allowed-to-do): Approval holds, audit trails, and evidence for compliance reviews
- [How to Test an AI Guardrail Before Deploying It](https://zespan.com/blog/backtest-guardrails): Replaying a rule on past traffic to see what it would have caught and wrongly blocked
- [Guardrails for Voice Agents and Real-Time AI](https://zespan.com/blog/guardrails-without-latency): Why proxy-based guardrails break real-time calls, and how in-process enforcement avoids it
- [What is AI Agent Observability?](https://zespan.com/blog/what-is-ai-agent-observability)
- [How to Monitor LangChain Agents in Production](https://zespan.com/blog/monitor-langchain-agents-production)
- [LangSmith vs Langfuse vs Zespan](https://zespan.com/blog/langsmith-vs-langfuse-vs-zespan)
- [Best AI Agent Observability Tools in 2026](https://zespan.com/blog/ai-agent-observability-tools)
- [Langfuse Alternatives](https://zespan.com/blog/langfuse-alternatives)
- [LangSmith Alternatives](https://zespan.com/blog/langsmith-alternatives)
- [Helicone Alternatives](https://zespan.com/blog/helicone-alternatives)
- [OpenAI Agents SDK Monitoring](https://zespan.com/blog/openai-agents-sdk-monitoring)
- [CrewAI Observability](https://zespan.com/blog/crewai-observability)
- [Google ADK Observability](https://zespan.com/blog/google-adk-observability)
- [Migrate from Langfuse](https://zespan.com/blog/migrate-from-langfuse)
- [Migrate from LangSmith](https://zespan.com/blog/migrate-from-langsmith)
- [Migrate from Maxim AI](https://zespan.com/blog/migrate-from-maxim-ai)

## Glossary

- [Silent agent failure](https://zespan.com/glossary/silent-agent-failure): An agent run that completes with no error but produces a wrong answer or takes a wrong action

## Setup

```bash
pip install zespan          # Python
npm install @zespan/sdk     # Node.js / TypeScript
```

```python
import zespan
zespan.init(api_key="YOUR_API_KEY")
```

```typescript
import { zespan } from "@zespan/sdk";
zespan.init({ apiKey: process.env.ZESPAN_API_KEY });
```

Providers are auto-patched and agents auto-discovered. Traces appear within seconds of the first agent run.

## Key Concepts

- **Silent failure**: An agent run that completes without any error but produces a wrong answer or takes a wrong action
- **Policy rule**: A check written as code in your repository, enforced on every agent request
- **Backtest**: Running a proposed rule against past production traffic to see what it would have caught and what it would have wrongly blocked
- **In-process enforcement**: The rule is evaluated inside your own service by the SDK, with no network call
- **Issue**: A group of failures with the same root cause, tracked as one problem
- **Regression test**: A test case built from a real production failure, so the same mistake is caught before it ships again

## Company

Zespan is built in India and serves teams globally. Self-hosted deployment available on the Scale plan.

- Website: https://zespan.com
- Email: letstalk@zespan.com
- Status: https://status.zespan.com