PyAI Conf
Register now
Datalayer logo
Data Science

Datalayer, a startup building AI-powered data analysis tools for Jupyter users, adopted Pydantic AI and Logfire after evaluating the agent frameworks market. With Pydantic AI's readable API and type safety, and Logfire's OpenTelemetry-based observability, they built a multi-protocol agent platform supporting AG-UI, ACP, Vercel AI, and A2A.

With Pydantic AI you have everything there readable. You have Python, it runs on Pydantic Graph. So this is also something I like. The graph is open and understandable.
Eric Charles, Founder & CEO, Datalayer

Products Used:

Pydantic AIPydantic Logfire
3 mins

Datalayer is a five-person startup founded by Eric Charles, an open source contributor to Apache and Jupyter. The team builds AI-powered data analysis tools on top of Jupyter, making it easier for data scientists to work with agents directly in their notebooks.

After pivoting from easy GPU scaling for Jupyter toward agentic AI, the team evaluated roughly 10 agent frameworks, including LangChain and ADK. The search proved frustrating.

"Compared to LangChain where we have Langsmith and different ways to access different blocks of features — with Pydantic AI you have everything easily readable," explains Eric. The fragmented APIs and documentation across frameworks made it difficult to understand what each tool offered and how the pieces fit together. The team needed a clear path to contribute and add the features required to support a variety of open protocols, letting agents communicate with each other and with end users.

As a small startup, direct access to framework maintainers mattered a lot. "If I open a question or a feature request on LangChain, I'm sure we'll be lost in so many others," Eric notes. They needed a framework backed by a responsive team they could actually reach.

Pydantic AI stood out for several reasons. "I read clearly what Pydantic AI offers as a strongly typed API. I read clearly what the docs are shipping and the type aspect is also something I care about," says Eric. “Easier access to the LLM context, multi-agents and multi-protocols like A2A, Vercel AI, AG-UI out-of-the box were also key to my team”.

The combination of a readable, type-safe Python API and Pydantic Graph sealed the decision. Eric appreciated that the graph layer was transparent and comprehensible. "The graph is open and understandable. If you need to go deeper, you can do it."

Community proximity was another decisive factor. "The developer team is smaller. So for us as a very small startup, this is something which is better because we can have this call, I can chat on Slack and so on. The proximity in terms of size and responsiveness is significantly higher."

For observability, the team adopted Pydantic Logfire to monitor their MCP Compose project, a tool that bundles multiple MCP servers and exposes them as a single endpoint. "I connected to Logfire sending OTL messages and it works very well," Eric recalls.

The OpenTelemetry foundation is a strong one. Datalayer can send custom telemetry events to Logfire's SaaS while also routing Logfire-instrumented data to their own collectors. "What excites me the most is that openness. You can use one or the other or both, and it always works well."

With Pydantic AI as their foundation, Datalayer built a complete agent platform that supports multiple transport protocols between the UI and the agent layer — including AG-UI, ACP, Vercel AI, and Google's A2A protocol. They extended A2A beyond its original agent-to-agent scope to also work between agents and front-end interfaces, contributing a streaming support PR to Fast A2A.

Datalayer project creation interface showing a new AI agent project setup with multi-protocol support

The team also implemented a code mode that optimizes tool usage and lowers LLM token consumption for data analysis tasks up to 90%, surfacing context details like token usage, system prompts, and tool definitions directly to users.

Agent details panel displaying token usage, system prompts, and tool definitions for a Pydantic AI data analysis agent

It is possible to visualise the long-running Pydantic AI agents optimized for Data Analysis from Datalayer’s Visual Studio Code extension.

Datalayer VS Code extension showing a long-running Pydantic AI agent performing data analysis in a rich editor view

Their open-source Jupyter MCP Server gained strong traction in the community, drawing significant usage and contributions. Now, the team is revamping their SaaS to bring long-running agents fully online, with users able to connect via MCP Client like Claude Desktop, VS Code, and other platforms.

Jupyter MCP Server demo showing an MCP client interacting with Jupyter notebooks through the open-source server

"I started saying open source is about openness and not being tight or prisoner of one provider."

— Eric Charles, Founder & CEO of Datalayer

With Pydantic AI and Logfire in place, Datalayer has achieved:

  • Straightforward migration: Moving from LangChain to Pydantic AI was smooth. "The migration has been easy," Eric confirms

  • Multi-protocol coverage: Supporting AG-UI, ACP, Vercel AI, and A2A from a single Pydantic AI codebase, broader than competing approaches.

  • Open observability: Bidirectional telemetry with Logfire, i.e. sending events to Pydantic Logfire and routing instrumented data to their own collectors, all via OpenTelemetry.

  • Community proximity: Direct access to the Pydantic team through Slack and calls, with feature requests that actually get heard.

  • Active contributions: Open source PRs to Fast A2A and strong traction on their Jupyter MCP Server.

"I find Pydantic is easier to interact with than the other platforms we tested."

— Eric Charles, Founder & CEO of Datalayer



Want to build AI agents with a framework that's clear, type-safe, and open? Get started with Pydantic AI.

Looking for LLM evaluation & AI observability for your application stack? Try Pydantic Logfire today!