Software Engineering Daily – FastMCP with Adam Azzam and Jeremiah Lowin

Date: April 7, 2026
Guests: Jeremiah Lowin (CEO, Prefect), Adam Azzam (VP Product, Prefect)
Host: Gregor Vand

Episode Overview

This episode dives deep into the evolution, design, and impact of FastMCP, an open source framework built atop the Model Context Protocol (MCP). Jeremiah Lowin and Adam Azzam of Prefect share the origin story, architectural pillars, adoption journey, and the technical philosophy that’s guiding FastMCP’s rapid growth in the agentic AI landscape. They further discuss new features such as code mode, their approach to ergonomic Python abstractions, the interplay between MCP, CLIs, and agent capabilities, as well as thoughts on the broader ecosystem.

Key Discussion Points & Insights

1. Backgrounds and the Genesis of FastMCP

• Jeremiah Lowin (02:05):

  • Career: Buy-side finance, risk, technology, machine learning, and data science.
  • Obsession: Building and automating tools for colleagues, often with unlimited software budget but no headcount, leading to a “find more hours in the day” approach.
  • Involvement: Original Airflow team member; founded Prefect in 2018 for more pythonic/data science-native workflow orchestration.
  • MCP Moment: Saw MCP as the link between programmatic and agentic workflows, prompting the first version of FastMCP as a “weekend project,” which later became a significant pillar at Prefect.

• Adam Azzam (03:48):

  • Background: Academic roots, PhD in mathematics, transitioned to data science and ML.
  • Startups: Built orchestration for LLM-powered job-seeking tools; became a customer and then employee at Prefect.
  • FastMCP Involvement: Approached Jeremiah after Prefect’s LLM orchestration library resonated with his own tech. Became “stewards” of FastMCP, focused on making it the best orchestrator for AI workflows.

“We’re not founders. We’re stewards, we’re maintainers.” – Jeremiah Lowin (08:08)

2. Origins, Growth & Adoption of FastMCP

• FastMCP as a Project, Not a Company (07:28):

  • Initially a personal side project under Jeremiah’s GitHub; moved under Prefect’s banner for 3.0 release following viral growth and official SDK adoption.

• The Decorator Pattern & Pythonic Abstraction (12:21–13:33):

  • Key insight was a simple, ergonomic decorator to register tools, mirroring familiar Python and FastAPI patterns, making MCP integration easy for Python devs.

“If we boil it all down...I wrote this decorator that was just useful.” – Jeremiah Lowin (12:21)

• Adoption Timeline & Traction (14:14–17:17):
  • Initial silence: “From November 26th to March, I don't think anybody cared.” (14:37)
  • Hockey stick moment: Spring 2025, OpenAI & Microsoft announced MCP support → repo stars/downloads skyrocketed.
  • Enterprise adoption: By late 2025, Databricks, Snowflake, MLflow, and others built official MCP servers leveraging FastMCP.
  • Engineering challenge: Mounting feature requests led to a deliberate re-architecture for 3.0, enabling future extensibility.

3. Pillars and Architecture of FastMCP 3.0

• Three Pillars (24:14–32:46):
  • Servers: Core—how to expose Python code and tools to an agent. Focus on authentication, authorization, versioning, modularity, latency, dependencies, and rapid deployment with sensible defaults.
  • Clients: Manage connectivity to MCP servers and surface available tools to LLMs. Importance of client design, as existing ones widely vary in feature coverage and quality.
  • Apps: Bridge for interactive UI/UX—"MCP apps" enable richer, more usable interfaces beyond chat markdown, leveraging user interface paradigms humans understand.

“FastMCP is getting very big. We need a way to organize it.” – Jeremiah Lowin (24:46)

• Client Quality Caveats:
  • Many clients only partially support MCP, often only tool calling, which limits protocol’s potential.
  • Standout clients: Goose, VS Code, Claude Code, MCP Jam (32:46)

4. Making Interactive AI Apps Feasible

• The UI Problem & Solution (34:21–39:30):
  • Most current MCP "apps" are SaaS apps shoved into chat windows, which doesn’t leverage decades of UI design.
  • Vision: Return interactive components (charts, tables, forms) as native Python return types via a new project, Prefab, enabling tight coupling and intuitive workflows for MCP server authors—without needing to write frontends in JS/TS.

“My dream is...if I know that I'm getting a bunch of data back, I want to return a bar chart in the same way that I would return a dictionary or a pydantic model.” – Jeremiah Lowin (38:02)

5. Code Mode: The Newest Paradigm Shift

• Problem: Standard MCP clients bloat LLM context by enumerating all tools, leading to inefficiencies and sequential execution.
• Solution:
  • Code Mode (39:30–49:21): Inspired by Cloudflare & Block, code mode lets LLMs write actual programs (scripts) over available tools. These are then run in secure sandbox environments (locally with Pydantic’s Monty, or externally with Modal, Daytona, Cloudflare, etc.).
  • Outcome: Dramatically simplifies complex interactions, parallelizes tasks, and enables incremental capability extension by server authors.

“Now your clients can submit programs over your MCP tools. You can spin up a local sandbox thread that executes that program, and that little sandboxed thread only has access to those tools, so it can't go do funny stuff.” – Adam Azzam (44:28)

• Real-World Release:
  • Codemode shipped same night as recording (FastMCP 3.1). Integrating it is often “one line of code,” exemplifying FastMCP’s commitment to ergonomic extensibility (49:26–50:13).

6. MCP vs. CLI: When and Why?

• OpenClaw & CLIs (51:25–58:03):
  • OpenClaw’s explosion showcased the power (and risks) of unsandboxed, direct agent access to CLIs.
  • MCP’s role: Establishing a contract between software and agent—regardless of surface (CLI, MCP server, API).
  • Internal vs. external deployment: MCP is overwhelmingly used in internal org contexts, where a well-typed contract and governance wins over ad-hoc CLI approaches.
  • Debate crystallized on Hacker News: For internal use, MCP is superior; for public, consumer-facing capabilities, CLI may suffice, but both will need a contract pattern.

“The vast majority of MCP use cases are inside companies for that company's own employees. ...You absolutely should make it an MCP server with a tight contract.” – Jeremiah Lowin (55:53)

“CLIs are probably a good MCP client if you squint your eyes.” – Adam Azzam (58:03)

• Governance, Permissions, and Capabilities (58:03–62:41):
  • Real business APIs require nuanced access control and bi-directional communication (long-running tasks, progress updates, identity-aware APIs), which MCP supports natively.

7. Community, Contribution, and the Future

• Contribution Stats (65:19):
  • 200+ individuals have contributed to FastMCP; rapid growth with every new feature/release.
  • Open for contributions: GitHub PrefectHQ/FastMCP
  • Docs: gofastmcp.com
  • Community is lively and responsive, with direct channels to maintainers.

Notable Quotes & Memorable Moments

• “It’s not air quotes here founders… We’re stewards, we’re maintainers.” — Jeremiah Lowin (08:08)
• “We were just trying to make it feel pythonic at the end of the day… there are pretty established patterns around this.” — Adam Azzam (13:33)
• “When you have a side project like this, you have your finger on the pulse of it. I still get an alert in real time on every single comment and issue.” — Jeremiah Lowin (17:17)
• “If you can’t innovate at that speed in this AI crazy world, I don’t know what you’re doing.” — Jeremiah Lowin (23:54)
• “MCP clients tend to differ wildly in their design and quality… that’s what really drives my choice to use any one specific provider.” — Adam Azzam (27:07)
• “If only I had a tool that just broadcast exactly what was available and how to call it, instead of having to write everything from scratch.” — Jeremiah Lowin on MCP vs CLI agent confusion (53:27)
• “You should always build a product for its user...CLIs are not designed for agents.” — Jeremiah Lowin (63:37)

Timestamps for Major Segments

| Segment | Timestamp (MM:SS) | |--------------------------------|------------------| | Introductions & Background | 01:23–07:24 | | Origin Story & Project vs Company | 07:24–08:36 | | MCP, Decorators, SDK Adoption | 08:36–13:33 | | Growth and Enterprise Adoption | 14:14–17:17 | | FastMCP 2 & 3 Evolution | 17:17–20:09 | | Three Pillars: Servers, Clients, Apps | 24:14–32:46 | | UI/UX for MCP Apps & Prefab | 34:21–39:30 | | Code Mode Deep Dive | 39:30–49:21 | | OpenClaw/CLI vs MCP Debate | 51:25–64:19 | | Community Contributions & Outro| 65:19–66:20 |

Conclusion & Takeaways

FastMCP demonstrates how the bridge between agentic workflows and developer ergonomics is built with insight, empathy for Python developers, and rapid community feedback. Its high-level abstractions, especially the decorator pattern, have made enterprise-scale agentic systems tractable in Python. The team’s willingness to rethink core architecture as adoption surged, plus innovations like code mode and UI DSL “Prefab,” ensure FastMCP remains at the forefront of agent workflow technology. The healthy debate around CLIs versus MCP showcases the project’s pragmatic philosophy: serve users first, and adapt patterns to fit real-world contexts—internal or external.

FastMCP is open, evolving, and community-first. Docs, code, and maintainers are all accessible for developers looking to join one of the most exciting subfields in modern software engineering.