Since the Model Context Protocol (MCP) was announced by Anthropic a year ago, we’ve seen immense growth in large language models (LLMs) and agentic use cases. Before MCP became the de facto agentic standard, developers building agents on top of LLMs would have to hard-code the connective tissue between the LLM and apps. Developers would need to build custom integrations between their LLM client and the apps required by an end user’s prompt. With MCP, developers can now connect directly with external data sources, so their LLM can read data from and write data to the connected applications.
But there’s a breaking point where things start to fall apart. The robustness and efficacy of agentic solutions depend on the quality of the application programming interfaces (APIs) that are used by an MCP server. MCPs expose tools that are invoked by LLMs, and these tools often reference individual API endpoints. The quality of APIs, therefore, directly correlates with the LLM client’s accurate discovery and execution of user prompts.
The hierarchy of developer needs
Delivering quality, consistent, and intuitive APIs is a matter of an organization’s cultural priorities. At Cisco, we’re fortunate to have executive leadership sponsorship of our platform API surface area, which helps us deliver quality APIs across the enterprise.
We’ve found that it’s helpful to prioritize API roadmaps based on a hierarchy of developer needs.
Maslow’s hierarchy of needs illustrates the theory that human motivation is driven by five levels of need. Arranged in a pyramid, these are: physiological, safety, love/belonging, esteem, and self-actualization. The theory suggests that people are motivated to fulfill basic needs first before progressing to higher-level needs for self-fulfillment.
Our hierarchy of developer needs takes Maslow’s pyramid and extends it to rank developer pain points and solutions according to basic needs, enterprise needs, and vertical or industry-specific needs.
The foundational elements: API coverage and completeness
The developer hierarchy of needs offers a framework for our product and engineering teams to prioritize their roadmaps. For example, the foundation of API quality is based on coverage or completeness. Without extant API endpoints, nothing upstream matters—not documentation, code samples, nor developer relations efforts.
Figure 1: The hierarchy of developer needs offers a framework for product and engineering roadmap prioritization.
Next comes the need for a high-quality OpenAPI Specification (OAS) and the internal engineering API development lifecycle. An OAS file could have lots of APIs, but if the prose around each endpoint is sparse, or certain endpoints are missing schemas and documented parameters, then it forces developers to either guess and test or reverse engineer which functions each API endpoint serves through rote testing. Both options offer a poor developer experience.
It’s important for any organization with a developer motion to invest in linting and static analysis of new APIs being developed, so that internal engineers can easily ship new API functionality without being experts in the API framework. A great example of this is Cisco DevNet’s open-source tool, API Insights, which allows developers to audit their API specifications to implement best practices as early as possible in the development cycle. Also, many people aren’t aware that if the OAS is missing schemas, it essentially means software development kits (SDKs) and infrastructure as code (IaC) tools like Terraform and Ansible cannot use those endpoints—regardless of their release status—since SDKs and IaC tools require the ability to auto-generate tooling from the OAS.
The moral of the story: All things depend on OAS, especially AI.
Documentation and scalability
The next level of importance is having intuitive documentation. If your APIs are fantastic but no one can find which one does what, or your information architecture is a nightmare, it negates the effort your team put into shipping quality APIs and OAS. Developers are not monoliths. Some are career software engineers, but many, especially in the networking industry, are technical professionals like networking engineers who are learning how to write scripts or build basic web apps using REST APIs for the first time in their career. Accordingly, great developer documentation is a must-have before anyone can understand what is possible for an AI agent use case.
Moving to the next level of developer needs, we have enterprise scale and quality. Organizations that sell to Fortune 500 companies or brownfield enterprises know that scale and the CIA-triad (confidentiality, integrity, availability) are mission-critical tenets. These tenets must be guaranteed before developers will feel comfortable building custom solutions on top of an API, regardless of whether those solutions are traditional scripts, app integrations, or agentic troubleshooting solutions.
At Cisco, we’re proud to closely partner with our largest customers and managed service provider partners to ensure that our platform works smoothly for everyone, from a mom-and-pop brick-and-mortar shop to a Fortune 100 global conglomerate that needs redundancy, immense scale, and rate limits, as well as the highest uptime available.
Simplifying API consumption and vertical application
Our penultimate level of developer needs is where we get into abstraction and obfuscation to simplify how APIs are consumed. SDKs and IaC tools like Ansible and Terraform are the bread and butter of large enterprises that require widespread automation. IT teams are growing leaner, and networking engineers are expected to do more with less. If all other developer needs have been met, it becomes easy for an organization to generate and maintain SDKs and developer tools like an MCP server.
For example, Cisco Meraki and Cisco Catalyst Center both maintain quality OAS files, which customers can use to generate an MCP server within a few minutes with popular API tools like Postman. This allows a developer who is trying to build a custom agent to be able to do so in days, not weeks or months, all because of the quality of our APIs, OAS, and docs, and our ability to ensure that quality at enterprise scale.
Finally, what really makes a developer platform shine are code samples and integrations. If all other developer needs are met, this creates an ecosystem condition where developers can easily create new scripts, integrations, and tools and share them with the platform community in the form of code samples, libraries, and integrations.
Ultimately, delivering complete, high-quality APIs, robust documentation, and an engaged ecosystem lays the groundwork for innovation and ensures that agentic solutions can reach their full potential.