← All speakers

Bio, Work & Ideas

Jeremiah Lowin

Conference affiliation: Founder & CEO · Prefect · 2026

Jeremiah Lowin is the founder and chief executive of Prefect and the creator of FastMCP, an open-source Python framework for connecting AI agents to tools and data. His career spans financial risk management, data orchestration, and agent infrastructure, with a consistent focus on making automated systems observable, dependable, and controllable.

Lowin studied economics and statistics at Harvard, earning a master’s degree in statistics while still an undergraduate. He joined King Street Capital in 2007 as the hedge fund developed its risk-management function, later founded the machine-learning consultancy Lowin Data Company, and subsequently became director of risk at another investment firm.

As maintaining analytical infrastructure overtook the analysis it supported, Lowin became an early Apache Airflow contributor and served on its project management committee. When Airflow proved insufficiently flexible for his data-science workflows, he built an internal alternative called Tin Man. Interest from other teams led him to found Prefect in 2018; its orchestration framework became open source the following year.

He extended that work into AI through Marvin, an agent and AI-application framework, before creating FastMCP. An early version entered the official Model Context Protocol Python SDK; FastMCP subsequently evolved into a separate, higher-level framework for building MCP servers and clients.

What agents need from software

Lowin treats an MCP server as a product interface for an imperfect user: an agent with limited working context, costly iteration, and incomplete knowledge of its tools. His AI Engineer session on MCP server design develops several practical principles:

  • Agent-native product design: Design tools around what an agent can accomplish, using clear names, simple arguments, constrained choices, and errors that explain how to recover. Tool examples influence model behavior so strongly that even incidental details can shape subsequent outputs.
  • Outcomes over operations: Encapsulate predictable sequences of API calls inside a single outcome-oriented tool. Conventional code should handle deterministic orchestration; agents are more useful when the necessary steps cannot be specified cleanly in advance.
  • Context-aware tool curation: Every tool description and schema consumes finite context, so exposing an entire REST API can overwhelm an agent before it begins. Automatic conversion can bootstrap development, but production tools require selective exposure, concise documentation, and progressive disclosure where clients support it.
  • Governance as infrastructure: Permissions, confirmation flows, observability, and deployment require actual infrastructure. FastMCP Cloud addresses hosted deployment, while Prefect Horizon manages how organizations distribute and govern agent-accessible tools and context.

Lowin supports interoperable, vendor-neutral standards through Prefect’s participation in the Agentic AI Foundation. His personal projects include copychat, which prepares code for model context, and claude-wt, which manages parallel Claude Code instances. In July 2026, he announced the FastMCP v4 beta, rebuilt on the newer MCP Python SDK.

That same month, Prefect acquired Dagster Labs, uniting two previously competing orchestration ecosystems. Lowin positioned Dagster around defining data outcomes, Prefect around reliable execution, and FastMCP around giving agents governed access to tools and information.

Read the topics behind these talks

2 conference talks

Key ideas

Scroll to read ↓

A useful MCP server curates workflows, arguments and context for its agent user. Jeremiah Lowin shows how to move beyond API wrappers—and where client behavior changes the design.

  • What makes a working MCP server a useful product?
    1:22 ↗
  • Discovery, iteration and context have different costs
    5:56 ↗
  • Turn order lookup into one agent story
    10:48 ↗
  • Make the valid arguments obvious
    18:21 ↗
  • Documentation and errors shape the next action
    21:44 ↗
  • A handshake can leave no room to work
    27:26 ↗
  • Reveal the relevant tools—and know your client
    30:09 ↗
  • Count tools from the agent’s perspective
    35:34 ↗
  • Bootstrap from REST, then design the product
    38:01 ↗
  • Argument dependencies and documentation placement
    43:00 ↗
  • Background execution changes who waits
    45:29 ↗
  • Ask for missing input during execution
    48:21 ↗
  • Direct tools and code mode
    50:27 ↗

Key ideas

Scroll to read ↓

Jeremiah Lowin explains how Prefab turns Python component trees into interactive MCP apps, then uses the same serializable representation to let agents generate interfaces. The useful constraint is a familiar enterprise job: sharing and collecting information through tables, forms, and charts.

  • MCP Apps let the agent initiate an experience while the person interacts with a real interface and its backend.
    1:12 ↗
  • Prefab’s scope makes Python UI composition practical: component trees, parameters, and reactive bindings cover structured information work without recreating the frontend ecosystem.
    4:22 ↗
  • The JSON protocol is the central architectural mechanism. A serializable UI can be created by a human, generated by an agent, or passed between them for modification.
    7:22 ↗
  • Changing a tool’s return value to a Prefab component produces an interactive result. Adding a grid and chart extends the team directory without replacing that working table.
    10:22 ↗
  • Direct upload separates capability selection from payload transfer: the agent opens the app, and the file reaches the server without being reproduced in model-generated tool arguments.
    13:22 ↗
  • Prefab changed generated-UI transport from JSON to a smaller Python representation, then converts it back to JSON after sandbox execution. Compact authoring and a serializable rendering protocol serve different jobs.
    7:52 ↗

References