Designing APIs for agents
In early 2025, Webflow started building for MCP before there was a clear playbook for agent-ready APIs. We publicly announced The post Designing APIs for agents appeared first on The New Stack .
Webflow launched its MCP server in early 2025 before establishing a clear strategy for agent-ready APIs. The initial approach was to wrap existing APIs as MCP tools, but this proved ineffective as developer APIs designed for human consumption do not align well with agents' operational needs. Agents require a more streamlined, intent-based interaction model that minimizes the need for manual context interpretation, granular endpoint management, and failure handling.
The challenge arose when agents began failing due to excessive tool calls required for simple tasks, leading to runtime inefficiencies and unreliable task completion. Directly exposing developer APIs resulted in low-level, overly chatty interactions that failed to provide the clear, actionable guidance agents needed to execute reliably. As a result, subtle errors crept in, and the overall user experience suffered.
To address these issues, Webflow iterated heavily, redesigning tools around intents rather than individual endpoints. This shift aimed to simplify schemas, improve tool-calling efficiency, and enhance response clarity for agents. The company also invested in foundational elements such as code layer and filesystem abstractions to support more dependable and powerful agent workflows.
These iterative improvements led to designs that resemble contemporary industry patterns, including task-oriented tools, agent-readable schemas, actionable error guidance, and APIs centered on intent rather than implementation specifics. The post highlights that designing for agents necessitates a broader reevaluation of how autonomous systems discover capabilities, coordinate execution, and operate reliably. It required reimagining the discovery of product surfaces and the runtime reliability of autonomous systems.
A key insight was that while exposing APIs through MCP provided a starting point, the underlying tool shapes and semantics were crucial for agent execution reliability. Early attempts to expose developer APIs directly as MCP tools resulted in inefficient workflows and increased failure rates. To overcome these challenges, the roadmap moved towards a layered tool architecture, which grouped capabilities into domain-level tools with composable actions, thus creating a more manageable and navigable tool space.
Additionally, Webflow experimented with filesystem abstractions and code representations of Webflow projects, allowing agents to interact programmatically and shell-style with project structures. This approach shifted the interaction model from API orchestration to execution environments and code-driven manipulation. By focusing on task-level tools and smart abstractions, Webflow aimed to minimize execution failure modes and enable agents to concentrate on fulfilling user goals rather than grappling with the intricacies of execution details.
Through these lessons and adjustments, Webflow's journey in designing APIs for agents aimed to create a more seamless, efficient, and reliable interaction model for autonomous systems.
Written by urgent.news from The New Stack's reporting — not their text. Machine-written — may contain errors; check the original before relying on it.
