Fiverr

Beyond the REST wrapper Software development is currently grappling with a fundamental misunderstanding of how artificial intelligence interacts with code. Jeremiah Lowin, founder and CEO of Prefect%20Technologies, argues that the industry is flooding the ecosystem with \"bad\" Model%20Context%20Protocol (MCP) servers. The core of the problem lies in the lazy habit of treating AI%20agents like human developers. Most creators simply point an MCP generator at an existing REST%20API and ship the resulting wrapper, assuming that if a human can use an endpoint, an AI can too. This assumption is not just wrong; it is architecturally damaging. Humans do not actually use APIs in their raw form; we build websites, mobile apps, and SDKs to shield ourselves from them. Agents, however, are forced to interface directly with these programmatic structures. When we give an agent a raw REST API, we are handing it a toolset designed for human strengths—one-time discovery and fast, cheap iteration—while ignoring the reality of agentic limitations. To build effective MCP servers, we must stop thinking in terms of infrastructure and start thinking in terms of product design. This means moving beyond the transport layer and focusing on the user interface of the future: the agentic interface. Three pillars of agentic interaction Designing for agents requires a fundamental shift in how we view discovery, iteration, and context. For a human developer, discovery is a one-time cost. You read the documentation once, understand the schema, and never look at the docs again for the life of that application. For an agent, discovery happens every single time it handshakes with a server. It must enumerate every tool and description, a process that is incredibly expensive in terms of token consumption and latency. Iteration follows a similar pattern of divergence. Human developers can run a script dozens of times a minute to debug a connection; it is fast and essentially free. For an agent, every additional call involves sending the entire history of previous calls back over the wire. Iteration is the enemy of performance. Finally, we must respect the limitations of context. While a human draws on years of memory and experience, even the most advanced Large%20Language%20Models (LLMs) operate with a limited \"brain\" of roughly 200,000 tokens. If your MCP server lobotomizes the agent on the initial handshake by consuming half its context window with documentation, the agent will fail before it even starts. The goal of a great MCP server is to find the needle in the haystack without forcing the agent to inspect every single piece of hay. Outcomes over atomic operations Engineers are traditionally trained to build atomic, granular operations. In a REST API, having separate endpoints for `get_user`, `get_orders`, and `filter_results` is considered a best practice. In an MCP server, this is a failure. Forcing an agent to act as a glue layer or an orchestrator is slow, expensive, and stochastic. Every round trip increases the chance of a hallucination or a timeout. Instead, we must design for outcomes. A single tool should map to a single agent story. Rather than providing three atomic tools that the agent must stitch together, provide one tool called `track_latest_order_by_email`. This buries the complexity of the API calls within the server-side logic, where it is fast and deterministic, and presents the agent with a clear path to success. This \"top-down\" workflow design ensures that the agent is not wasting its limited reasoning capabilities on basic plumbing that a human developer should have already handled. Argument flattening and schema discipline A recurring trap in MCP development is the use of complex, nested arguments. Developers often pass dictionaries or configuration objects, assuming the agent will intuit the structure. This often leads to \"doubly documented\" tools where the system prompt and the tool schema disagree, leaving the agent to guess which is correct. Lowin points out that many popular clients, including Claude%20Desktop, have historically struggled with structured object arguments, sometimes converting them to strings and breaking the handshake. The solution is radical simplicity: flatten your arguments. Use top-level primitives like strings, integers, and booleans. When choices are constrained, utilize literals or enums to provide a strict boundary for the agent. This reduces the cognitive load on the model and ensures that the arguments sent from the client match the expectations of the server. By naming arguments for the agent rather than the developer, you create an interface that is self-describing and resistant to the common pitfalls of LLM-based tool calling. The economy of the token budget The most overlooked constraint in MCP design is the token budget. Every character in a docstring, every field in a schema, and every example in a prompt costs tokens. Lowin highlights a cautionary tale of a company attempting to expose 800 endpoints via MCP. At that scale, the mere act of telling the agent what tools are available consumes the entire context window, leaving zero room for actual problem-solving. This is the \"handshake overflow,\" and it is the primary reason many enterprise-grade MCP servers feel sluggish or \"dumb.\" We must curate ruthlessly. A server with more than 50 tools is a red flag. If you find yourself exceeding this limit, it is time to namespace your tools or split the server into smaller, specialized units. One of the most effective ways to save tokens is to use \"progressive disclosure.\" Instead of documenting every edge case in the main tool description, use helpful error messages. In the agentic world, errors are prompts. If an agent calls a tool incorrectly, the server should return an error message that provides the necessary context to fix the call. This moves the token cost from the handshake (which happens every time) to the error recovery (which happens only when needed). Curation as the ultimate design goal The transition from infrastructure-thinking to product-thinking is the final hurdle for the MCP ecosystem. Tools like FastMCP have made it trivial to bootstrap a server by mirroring a REST API, but this should only ever be a starting point. The real work begins with curation. We must move toward \"context products\". These are highly optimized, specific interfaces that give an agent exactly what it needs to achieve a specific result, and nothing more. Treating an MCP server as a user interface changes the development lifecycle. It requires evaluation, testing against specific models, and an understanding of how different clients like Cursor or Claude%20Code handle the protocol. As the ecosystem matures, the focus will shift away from how we connect models to data and toward how we design the surface area of those connections. The developers who succeed will be those who view their servers not as a collection of functions, but as a carefully crafted experience for the most important new user in tech: the AI agent.