Your MCP Server is Bad (and you should feel bad) - Jeremiah Lowin, Prefect
TL;DR
Jeremiah Lowin argues that most MCP servers fail because developers treat them like REST APIs for humans rather than curated interfaces optimized for AI agents' specific constraints around discovery cost, iteration speed, and limited context windows.
🧠 The Agent-Human Divide 3 insights
Discovery is prohibitively expensive
Unlike humans who study documentation once, agents must rediscover the entire server on every activation, burning tokens to enumerate every tool and description.
Iteration is the enemy
While humans iterate code rapidly, each additional agent tool call transmits the full conversation history over the wire, making multi-step workflows slow and costly.
Context windows are severely constrained
Agents operate with limited memory (around 200k tokens) compared to human long-term memory, requiring interfaces that minimize cognitive load and decision points.
🎯 Outcomes Over Operations 3 insights
Atomic operations are an anti-pattern
Exposing granular functions like get_user and filter_orders forces agents into expensive orchestration instead of single-call solutions that return complete outcomes.
Agents make terrible glue code
Using LLMs to chain atomic operations is slow, stochastic, and hard to debug compared to deterministic orchestration tools like Prefect or Airflow.
Design for agent stories
Tools should represent complete workflows (e.g., 'track latest order by email') rather than steps that require agent reasoning to sequence and execute.
🎨 The Art of Curation 3 insights
Raw API wrappers fail agents
Simply stringifying REST API responses creates 'needles in haystacks' where agents must examine every field to find relevant data, consuming excessive context.
Agents deserve purpose-built interfaces
Just as humans use websites and apps instead of raw APIs, agents need interfaces curated specifically for their strengths and weaknesses, not repurposed human developer tools.
Curate ruthlessly to minimize discovery
Every exposed tool and description adds to the discovery tax, so servers must eliminate unnecessary surface area and optimize for the agent's limited context window.
Bottom Line
Design MCP tools as complete outcome-oriented workflows rather than atomic API operations, curating strictly for agent limitations on discovery, iteration, and context.
More from AI Engineer
View all
Agentic Search for Context Engineering — Leonie Monigatti, Elastic
Leonie Monigatti from Elastic argues that context engineering is fundamentally 80% agentic search, evolving from rigid RAG pipelines to dynamic agent-driven retrieval that must navigate diverse context sources through carefully curated, specialized search tools.
Playground in Prod - Optimising Agents in Production Environments — Samuel Colvin, Pydantic
Samuel Colvin demonstrates optimizing AI agent prompts in production using Jepper, a genetic algorithm library that breeds high-performing prompt variations, combined with Logfire's managed variables for structured configuration and deterministic evaluation against golden datasets.
Vibe Engineering Effect Apps — Michael Arnaldi, Effectful
Michael Arnaldi demonstrates "vibe engineering" by building a TypeScript project with AI agents, revealing that cloning library repositories directly into your codebase—rather than using npm packages—enables AI to learn patterns from source code, while strict TypeScript and custom lint rules act as essential guardrails.
Everything You Need To Know About Agent Observability — Danny Gollapalli and Ben Hylak, Raindrop
As AI agents grow more complex and autonomous, traditional pre-deployment testing fails to catch the infinite edge cases of production behavior. The video outlines a new observability paradigm combining explicit system metrics with implicit semantic signals and self-diagnostics to monitor agents in real-time.