Asro
In the rapidly evolving landscape of artificial intelligence, a new type of visitor is knocking at your API’s doorstep. It isn’t a human developer with a browser and a coffee, nor is it a legacy script managed by a centralized DevOps team. It is an agent—a sophisticated autonomous entity like an OpenAI Operator or a research-focused Claude instance—seeking to perform a task on behalf of a user. These agents do not have "business days" to wait for manual approval from your Developer Relations team. They require an immediate, verifiable, and secure way to register, authenticate, and begin executing tasks.
Yet, despite the rise of agentic workflows, the infrastructure that powers the modern web—the ubiquitous API gateway—remains fundamentally anchored in the human-centric era. If your API management platform doesn’t support autonomous onboarding, you are effectively leaving your digital assets locked behind a door that only opens for human hands.
The Architecture of the Problem
The current state of API management is built on a "manual-first" paradigm. When a developer wants access to an API, they visit a portal, fill out a form, wait for a human to review the request, and eventually receive a credential via email or a secure dashboard. This workflow is fundamentally incompatible with the speed and scale of AI agents.
An agent arriving at your API carries a specific set of requirements:
- Verifiable Identity: A cryptographically signed request, utilizing standards like Web Bot Auth over RFC 9421.
- Published Purpose: A clear, machine-readable declaration of what the agent intends to do.
- Scoped Permissions: A request for specific, limited access that matches the agent’s task.
While modern Tier 1 API gateways—such as Kong, Apigee, Tyk, and AWS API Gateway—possess all the internal mechanics to handle these requests (creating a consumer, issuing a key, attaching a policy, and streaming an audit event), they lack the compositional layer to bring them together. No gateway vendor currently offers a "self-onboarding" endpoint that takes a signed request and orchestrates these disparate gateway functions into a single, seamless round trip.
Chronology: A Week of Gateway Audits
To understand the depth of this technical gap, I spent the last week auditing every major API gateway and management OpenAPI specification within the API Evangelist network. The objective was simple: find the operations that could compose into an "agent self-registers" flow.
The audit included Kong, Apigee, Tyk, WSO2, Gravitee, AWS API Gateway, Azure APIM, Google Cloud API Gateway, MuleSoft, and Workato. The findings were consistent across the board. Every gateway provides the necessary atomic operations to fulfill an onboarding request. However, the "missing link" is the orchestration layer.
- Days 1-3: Mapping the atomic operations. I cataloged the specific paths for creating identities, scope-tiers, and credential minting across 75 different providers.
- Days 4-5: Identifying the "seam." It became clear that the agent-onboarding flow is not a feature that a gateway vendor will—or should—build into their core product. It is a capability.
- Days 6-7: Developing the reference architectures. I codified these findings into ten distinct "Naftiko Capabilities"—declarative, domain-aligned units of integration that act as a bridge between the agent and the gateway.
Supporting Data: The Capability Matrix
The following table summarizes the status of the ten major gateways evaluated during this research. The variations highlight the diverse data models and trust affordances currently in use across the industry.
| Gateway | Primary Challenge | Audit Integration |
|---|---|---|
| Kong | Requires 13 native MCP control-plane ops | Event Gateway |
| AWS API Gateway | Dual identity (IAM + Web Bot Auth) | CloudWatch/CloudTrail |
| Apigee | Requires Developer/App/Product composition | Cloud Audit Logs |
| WSO2 | DCR-native (POST /register) | Native Audit |
| Tyk | Collapses identity/scope into one call | MDCB sync |
| Azure APIM | Nested scope (Product/Subscription/User) | Azure Monitor |
The data confirms that while the gateways are functionally capable of performing the task, the "agent-onboarding" logic is a distinct layer that must sit in front of the infrastructure. By treating onboarding as a portable capability, providers can avoid vendor lock-in while ensuring that their security policies—such as verifying Web Bot Auth signatures and asserting consent hashes—are consistently applied regardless of the underlying gateway technology.
Implications: The Move Toward Agentic Governance
The shift toward automated agent onboarding has profound implications for API governance. Historically, governance was a manual "gatekeeper" process. In the agentic future, governance must become an automated, lint-time, and runtime reality.
The Three-Layer Governance Model
The architecture proposed here relies on a three-layer split, ensuring that logic is separated from implementation:
- Ikanos (The Specification): This is the capability spec (the YAML configuration) that defines the orchestration. It acts as the "how-to" guide for the gateway.
- Polychro (The Governance Layer): This layer handles linting. It ensures that any onboarding capability adheres to strict security standards—such as requiring a
verify_signaturestep andemit_auditoperation. - Naftiko Fleet (The Operations Layer): This is the execution environment that governs capabilities at scale across teams and compliance boundaries.
By decoupling the capability from the gateway, organizations can update their onboarding policies without ever touching the gateway configuration itself. If a new security regulation mandates a change in how agent identities are verified, the provider simply updates the orchestration YAML.
The Future of the "Doorway"
The traditional concept of a "developer portal" is evolving into a "gateway doorway." While the doorway still contains the essentials—.well-known/api-catalog, MCP (Model Context Protocol) endpoints, and agent skill templates—the automated framing is the new differentiator.
An API portal that requires a human to file a Jira ticket is merely a static site. A doorway that recognizes a signed agent, validates its credentials, and provisions access in a single, secure round trip is a dynamic, high-velocity engine. This is not just a theoretical improvement; it is a necessity for any organization looking to participate in the burgeoning agent-to-agent economy.
Why This Design is Public
I am choosing to publish these designs before a live, production-ready implementation for three strategic reasons:
- Collaboration: I am actively seeking design partners. Every major commercial API gateway now has a committed reference capability, but they need to be battle-tested against real-world customer tenants.
- Standardization: The industry is currently fragmented. By publishing the operation-by-operation map, I am providing a common language for providers to discuss agent onboarding. We should not have to reinvent the wheel every time a customer asks, "Can your agent self-register?"
- The Work is the Message: For fifteen years, the API Evangelist philosophy has held that the best way to drive industry change is to provide the architectural blueprint. Whether these reference implementations are executed by my team, by vendors, or by the community, the capability shape itself is the essential contribution.
Conclusion: Bridging the Gap
We are entering an era where the primary consumer of your API will not be a human. If your strategy for handling these autonomous visitors is still rooted in the manual workflows of the 2010s, you are effectively invisible to the most productive agents on the web.
The tools to fix this exist. The gateway operations are already sitting in your OpenAPI definitions, waiting to be composed. By shifting our perspective from "managing gateways" to "deploying capabilities," we can create a secure, automated, and scalable future for agentic interaction. The doorway is open—all you have to do is build the threshold.
Suro Senen
