Healthcare hallucination rate
65.9%
Hallucination rates of "raw" LLMs in healthcare-related environments
Official implementation partner Pydantic Development Services
Validate, build and observe on one Pydantic platform.
Vstorm, an official Pydantic implementation partner, works across the whole Pydantic lifecycle — the open-source validation library, the Pydantic AI agent framework, and Logfire for everything after deploy. Typed data contracts, agents your systems can trust, and live visibility into agent behaviour, cost, and quality drift in production.
Trusted by operators
-
+11.76% orders from day 1Three-agent product advisor guiding customers through print-order configuration.
Read case study -
Supply chain intelligence agents reducing manual coordination overhead.
-
37 kernels ported from CUDA to Intel GaudiProduction AI workloads moved to new hardware for on-prem LLM deployment.
-
AI agent implementation for a global automotive enterprise.
-
2 hrs → 3 min to generate a workflowText-to-workflow agents building validated node graphs inside the platform.
Read case study -
0 hallucinations across 329+ validation scenariosHIPAA-compliant agentic RAG over proprietary clinical triage guidelines.
Read case study
One platform, three layers
The trusted partner for Pydantic in production
Pydantic is not a shelf of separate tools — it is one platform covering the full AI engineering lifecycle. The open-source validation library holds your data contracts. Pydantic AI runs typed agents on top of them. Logfire, the team's commercial observability product, tells you what those agents actually do once they are live. Vstorm, an official implementation partner, works across all three.
We contribute to pydantic-ai on GitHub — filing issues, contributing fixes, and working with the Pydantic core team. Focused specifically on the agent runtime? See our Pydantic AI development services.
"Vstorm haven't just adopted Pydantic AI, they've helped shape it — contributing extensions, pushing on the rough edges, and showing us where real-world agent systems break. That kind of collaboration is gold for an open source project."
Samuel Colvin, Founder & CEO, Pydantic
- 01
Controlled outputs
Outputs are validated against typed schemas, so malformed or hallucinated values are caught before they reach production.
- 02
Settings management
Configuration and settings management.
- 03
Pipeline validation
Data in the pipeline needs to be validated and checked before processing.
- 04
Quality extraction
The extracted data must meet a defined quality bar, validated at the boundary.
- 05
Typed contracts
Typed contracts at service boundaries.
The Risk Without Validation
Why this distinction matters in production
These numbers reflect what happens when LLM outputs are not validated against typed schemas.
The platform addresses this at every layer of the lifecycle. Pydantic catches malformed data entering and leaving your Python services. Pydantic AI catches malformed or schema-violating LLM outputs at the agent boundary. Logfire catches what only shows up once real traffic hits the system — behaviour that drifts, costs that creep, and eval scores that slide after a model or prompt change.
Multi-agent chain reliability
20%
End-to-end success in a 10-step workflow when each step is ~85% reliable — compound failure across the chain, not a single bad model.
Case Studies
Production systems with validated outputs
Next step
Put typed contracts around your LLM outputs
A 30-minute call with an engineer — we review where unvalidated outputs put your pipeline at risk and what a validation layer would take.
Our process
From use case to production — the TriStorm methodology
We do not start by building. We start by finding the right thing to build. TriStorm is our three-phase framework — from Pydantic feasibility to a validated production system your team owns.
Strategic alignment and planning
Consulting-led planning before any code. Deep interviews and scoping workshops to frame the problem, map where Pydantic and Pydantic AI create the highest operational leverage, and produce a prioritized roadmap with an ROI model per use case.
- Deep interviews and scoping workshops with your operations and technical leadership
- Where Pydantic and Pydantic AI create the highest leverage across your Python and AI stack
- Prioritized roadmap with an ROI model per use case
Proof of Value
We assess where Pydantic and Pydantic AI fit in your Python and AI architecture, build a proof of value in context, and surface potential problems or improvements before full build.
- Assessment of where Pydantic and Pydantic AI fit in your Python and AI architecture
- Proof of value that shows the solution in context
- Team finds potential problems or improvements before full build
Process augmentation
We embed with your team to ship the production-ready solution on the Pydantic stack — data and output validation at every boundary, pipeline stability verified under production-like conditions — and transfer ownership so your engineers run and extend it without us. No vendor lock-in.
- Production-ready solution on the Pydantic stack, validated at every boundary
- Embedded engineering and structured knowledge transfer — runbooks, not a doc drop
- Ownership transferred to your team; no vendor lock-in
Layer three · after deploy
Logfire — what your agents actually do in production.
Shipping is the middle of the lifecycle, not the end. Logfire is the Pydantic team's OpenTelemetry-based observability product — the reason the platform does not stop at the build. Free tier and usage-based plans; because it exports OTel, the same data can flow to Datadog, Grafana, or Honeycomb instead.
- 01
Agent behaviour, traced step by step
Real-time traces of every LLM call, tool call, and retry — a wrong answer is a span you can open, not a mystery. Native Pydantic AI integration instruments the agent graph without extra wiring.
- 02
Cost, before it becomes a surprise
Token and cost tracking per call, per agent, per workflow — including the small retry overhead of validation failures, and which model or prompt changes actually move the bill.
- 03
Quality drift, caught by evals
Eval-based monitoring with Pydantic Evals, so a model upgrade or prompt tweak that quietly degrades output quality shows up as a failing score — not a support ticket three weeks later.
18:20:28 agent run 12.2s
18:20:28 chat gpt-5 12.2s
message
agent run
span_name agent runotel_scope pydantic-aikind spantrace_id …4dd426
span took 12.2s
↗ input · system
Extract information about the city
↗ input · user
London is home to over nine million people, making it the largest city in the United Kingdom…
Why Vstorm
Three reasons mid-market and enterprise teams work with us on Pydantic
We have been building production Python systems since 2017 and contributing to the Pydantic AI framework since beta — across the validation library and the agent framework.
01
Experience — 30+ production deployments on the Pydantic-powered stack
Deep expertise across Pydantic, Pydantic AI, FastAPI, LangGraph, CrewAI, and LlamaIndex. Our 25+ AI engineers deliver type-safe solutions tailored to your existing Python services — whether the problem is at the data layer or the agent runtime layer.
02
Stack — the whole platform, not one layer of it
We work across all three layers as one lifecycle: Pydantic for schema enforcement, Pydantic AI for agent orchestration, and Logfire for observability and OpenTelemetry export once the system is live. Every project is accurate, debuggable, and cost-controlled after go-live — not only at the moment it ships.
03
Support — ownership across the full lifecycle
From consultation through deployment and into the operating phase: Logfire dashboards your team actually reads, eval suites that flag drift, and upgrades to new Pydantic AI releases and Pydantic v2 schema changes as the ecosystem evolves.
FAQ
Frequently asked questions
What is Pydantic?
Pydantic is the most widely used data validation library in the Python ecosystem. It uses type hints to define schemas and validates data against them at runtime. Malformed inputs surface as structured errors — not silent failures. Its Rust core makes it one of the fastest validation libraries available. It is the validation layer underneath the OpenAI SDK, the Anthropic SDK, FastAPI, and LlamaIndex.
What is Pydantic AI and how is it different from Pydantic?
They are two layers of the same platform, not competing choices. Pydantic enforces data schemas at runtime across any Python application — the contract layer. Pydantic AI is the agent runtime built on top of it by the same team, adding type-safe agents, validated tool calls, dependency injection, streaming validation, and automatic retries on malformed LLM outputs. Logfire then covers the third layer, observability after deploy. Most teams end up using all three: contracts underneath, agents on top, and traces telling them what happened in production.
Do I need Pydantic, Pydantic AI, or both?
It depends on where your problem lives. For typed schemas in FastAPI, validated config settings, or ETL pipelines — use Pydantic. For LLM agents that must return structured, validated outputs — use Pydantic AI. Many production systems use both: Pydantic at the data layer, Pydantic AI at the agent layer.
What are the main use cases for Pydantic (without the AI framework)?
Enforcing data contracts in FastAPI or Django Ninja APIs, managing application configuration with type safety, validating inputs and outputs in ETL pipelines, serializing and deserializing nested data structures, and generating JSON schemas from Python models. None of these require Pydantic AI.
Does Pydantic AI work with any LLM provider?
Yes. Pydantic AI supports OpenAI, Anthropic, Google, Groq, Mistral, Cohere, AWS Bedrock, and any OpenAI-compatible API, plus locally hosted models. You can swap providers without rewriting agent logic. The framework supports fallback chains to route to a cheaper or faster model when the primary one is unavailable.
What is Pydantic Logfire?
Logfire is the Pydantic team's OpenTelemetry-based observability product for Python and AI workloads — the commercial layer of the platform, alongside the open-source library and agent framework. It provides real-time LLM call traces, cost tracking, eval-based monitoring, and native Pydantic AI integration. It has a free tier and usage-based paid plans, and because it exports OTel you can send the same data to Datadog, Grafana, or Honeycomb instead of running Logfire as a standalone backend.
Why does observability belong in the same conversation as validation?
Because validation and observability catch different failures. Typed schemas stop malformed data and schema-violating LLM outputs at the boundary — that is a build-time guarantee. What they cannot tell you is whether a shipped agent still behaves the way it did on day one. Agent behaviour drifts as models are upgraded and prompts are edited, token costs creep as usage patterns change, and eval scores slide quietly. Logfire closes that loop, which is why we treat it as part of the AI engineering lifecycle rather than an add-on after go-live.
Get started
Ready to build your Pydantic solution?
Whether you are enforcing data contracts in an existing Python service, retrofitting validation onto an LLM pipeline, or building a Pydantic AI agent from scratch — our team can scope the problem, design the right stack, and take you from concept to production.