Samuel Colvin

Samuel Colvin is the creator of Pydantic and founder and CEO of its commercial namesake. His AI developer-tool work includes Pydantic AI, Logfire and Monty: tools for defining agents’ inputs and outputs, observing application execution and controlling what generated code can access. The original Python validation library supplies a mechanism useful across this work: one data definition can generate a schema describing expected model output and validate what returns.[1][2][10]

Colvin’s September 2025 Pydantic AI v1 announcement states his position plainly: “building GenAI applications is still just engineering.” He advocates type checking, dependency injection, validated outputs, tested documentation examples and OpenTelemetry observability. In his February 2025 interview, he acknowledged a trade-off: the framework’s extensive generics could make it harder to learn, but he considered typing important for production applications in large systems.[9][2]

The Pydantic AI bank-support example makes these boundaries concrete. Application-supplied dependencies carry customer identity and a database connection; tool signatures and docstrings describe functions available to the model; an output model declares support advice, a card-blocking decision and a risk value constrained between zero and ten. Tool arguments are validated before the application function runs, and validation errors can prompt another model attempt. These checks enforce declared structure and constraints; they do not establish that the advice or business decision is correct.[10]

Colvin connects tested documentation to years of maintaining Pydantic and receiving complaints about outdated examples. He described the team’s pytest-examples tooling extracting Python from Markdown and docstrings, running it and checking it with linting. For Pydantic AI, he said documentation examples and their printed outputs were checked during tests, making examples part of the maintained code rather than separate instructions that could drift.[2]

Graphs were a documented change of mind. Colvin recalled initially arguing that ordinary Python control flow was sufficient, then reconsidering as users supplied workflow examples and he recognized the appeal of structure in systems that could become spaghetti code. In the February 2025 interview, he described nodes whose return annotations declare possible next nodes and whose execution returns the actual next node. The team could infer transitions—and generate a Mermaid diagram—from those annotations. He said the agent implementation had itself become a graph without changing its public API.[2]

Colvin illustrated the value of resumable workflows with an e-commerce return: one transition might be a function call, while another waits six days for a customer to post a parcel. At the February 2025 interview, database persistence between nodes was still unfinished. His September 4, 2025 v1 announcement included human approval for tools and production-ready Temporal agent durability, while listing durable graph execution separately as forthcoming. The project subsequently released stable Pydantic AI v2.0 on June 23, 2026.[2][9][17]

With Logfire, Colvin advocates general-purpose application observability with first-class AI support. In February 2025, he argued that seeing model activity without the rest of an application was insufficient. He also explained why Logfire lets users query their data directly with SQL: the team did not know all the answers about evaluating AI systems, so users needed room to devise their own analyses. He announced Logfire leaving beta on October 1, 2024, alongside a $12.5 million Series A led by Sequoia with other existing investors participating.[2][8]

That emphasis on user-written SQL shaped database choices. Colvin explained that SQL ergonomics, open-source availability and the team’s Rust expertise favored Apache DataFusion as a toolbox for building Logfire’s database. He described personally improving a string-comparison kernel and adding JSON support over a weekend using the JSON parser built for Pydantic Core. The choice let the team modify internals in a language it knew.[2]

In March 2026, Colvin announced consolidating Pydantic AI Gateway management into Logfire. His rationale was concrete: separate routing and observation products required different accounts, API keys and dashboards, making application behavior harder to understand. Consolidation connected gateway requests to broader traces containing agent steps, tool calls and validation results. Single-invoice billing remained work in progress in that announcement.[16]

In his February 2026 Monty essay, Colvin argued for letting agents write Python that combines tool calls, loops, conditionals and data transformations. Monty is the team’s Rust interpreter, using Ruff’s parser, with host access supplied explicitly through functions and mounts. Its design includes resource limits and serialized execution state that can be resumed later. Colvin’s principle is to “start from nothing, then selectively grant capabilities.” This gives generated code selected ways to act without automatically supplying a full operating-system environment.[11][12]

Monty’s security boundary required qualification after a public bounty challenge. In the May 2026 postmortem, maintainer David Hewitt reported that Owen Kwan of Veria Labs achieved an escape exposing a secret environment variable within 48 hours; Stanislav Fort identified a separate virtual-filesystem weakness. Hewitt traced the escape to unsafe Rust assumptions combined with garbage-collector deficiencies that freed an object while it was still in use. The team reported patching the escape in v0.0.16, correcting garbage-collector rooting and hardening filesystem behavior.[13]

In July 2026, Colvin explained two further implementation pressures. Maliciously crafted Python could crash the parser, so the team moved parsing and execution into subprocesses to contain failures. Separately, testing CodeMode in Pydantic AI Harness revealed workloads needing full CPython or a virtual machine. A protobuf protocol developed for subprocess communication could also communicate with CPython in provider sandboxes over WebSockets. Colvin presented a unified Logfire sandbox interface, with Modal planned as the initial full-CPython provider, and sought early-access design partners.[14]

By August 2026, Colvin described subprocess workers providing stronger resource control and a remote WebSocket runner separating the execution machine from the agent’s host. He reported no sandbox-boundary crossing in the second bounty round, while acknowledging crashes, resource-limit edge cases and compatibility gaps. He announced a third round with a $20,000 bounty and planned a stable Monty v1 afterward.[15]

These AI tools followed Colvin’s earlier work on general-purpose Python validation. He began Pydantic in 2017, using Python type annotations to define expected data. An annotation does not itself enforce an incoming value’s type; Pydantic adds runtime validation and compatible conversions. For example, a numeric string can become an integer. Strict mode lets developers constrain coercion.[4][2][5]

Colvin credits Sebastián Ramírez, FastAPI’s creator, with adding JSON Schema support before Pydantic v1. He recalls first encountering Ramírez through a weekend of contributions made for OpenAPI. That API-oriented addition later let one definition both describe structured outputs and tools to language models and validate returned data; AI was not its original purpose.[2]

Colvin recalls starting the Rust rewrite in early 2022 and working on it full time for roughly a year and a half, with colleagues joining after company formation. The v2 alpha announcement, coauthored with Terrence Dorsey, explains the architectural split: validation moved into Rust’s `pydantic-core`, while the Python layer largely generates schemas consumed by validators and serializers. Pydantic 2.0 shipped June 30, 2023, with breaking changes and a bundled v1 namespace supporting incremental migration.[2][5][6]

Company formation overlapped with the rewrite. Colvin announced the company on February 16, 2023; TechCrunch reported $4.7 million in seed financing led by Sequoia. His immediate priorities included hiring and finishing v2, while broader plans concerned cloud services and developer tools. On a Talk Python panel, he recalled spending his own money on full-time development before investment and described the pleasure of hiring friends he knew through open-source contributions.[3][4][7]

Colvin committed at founding to keeping Pydantic open source and MIT licensed. In February 2025, he distinguished the company’s licensing choices explicitly: Pydantic and Pydantic AI were MIT licensed, while Logfire was closed source and openly for profit. He regarded the libraries as the company’s open-source contribution and said there was no immediate plan to open-source Logfire.[3][2]