Keep the API gateway you already need; add agent-specific controls only where testing exposes a gap. The useful comparison is tool authorization, downstream identity, approval state and evidence, not the product label. Follow one proposed workflow: a support agent acts for finance analyst Priya, looks up an invoice and requests a refund through the same MCP server.
Architecture and product boundaries reviewed October 28, 2026. The scenarios below are evaluation tests, not a report of a deployed customer benchmark. Capabilities depend on the product, version and connection mode.
Where an API gateway and an agent gateway genuinely overlap
An API gateway is an entry point for API requests. An agent gateway is an entry point for supported agent or tool traffic. The categories can share a data plane and controls.
TLS, mTLS and OAuth caller checks still matter for agent traffic. Request counts remain useful as a backstop, but do not directly measure token cost. Kong, for example, runs its AI Gateway through plugins on Kong Gateway. Its MCP documentation lists proxy and OAuth2 plugins, plus MCP logs with session IDs and JSON-RPC methods. The deployed plugin determines which MCP fields the gateway can inspect.
Lowercase agentgateway, one word, names a specific open-source project, not the whole category. Solo.io contributed it to the Linux Foundation in 2025 as a data plane for agent traffic, including MCP and A2A.
Check its editions separately. Solo’s feature overview lists OAuth scope restriction and policy-driven tool exposure under Enterprise. Do not assume the open-source build includes every commercial control.
Compare three things: which request fields the policy can inspect, which identity reaches the business system, and where the workflow keeps state. Test the configured path. The category name does not answer those questions.
Follow one delegated agent call through your API gateway
In this example, Priya is checking a duplicated charge. The billing MCP server sits behind the company’s existing API gateway.
Hop 1: the route is one POST, whatever the tool
An MCP tool call uses a JSON-RPC body. The invoice lookup and refund can both arrive as POST /mcp with method tools/call. Their tool names differ inside the body. An ordinary route rule for GET /invoices versus POST /refunds cannot distinguish those MCP calls from the URL alone.
The 2026-07-28 Streamable HTTP transport also puts selected method and tool metadata in HTTP headers. A gateway can use those fields without parsing the body; the server validates them against the request. Check the revision your client and server use. A tool name helps route the call, but does not authorize the refund or validate its arguments.
Hop 2: preserve the workload and the person it acts for
Two identities matter: the agent and Priya, the person it acts for. Microsoft’s Entra agent-identity guide distinguishes autonomous from delegated access. Record which principal the billing service actually checks. Claims mapping or an external access service may help, but the gateway label does not prove the delegation works.
Hop 3: discovery filtering is separate from execution authorization
Before a call, the client can discover the tool’s definition. Review it: tool descriptions can carry malicious instructions. Catalogs such as AgentCore Gateway help clients find tools. They do not replace the access check when a tool runs.
Give an unauthorized test user the server ID and tool name. The explicit call must fail too; hiding its search result is not enough.
Hop 4: the task outlives the response
The agent proposes the refund, but a named person must approve it. The A2A specification models interrupted tasks. MCP elicitation can request input. Neither proves the refund waits for the right approver.
Find the component that stores approval state. Test rejection, expiry, retries and a direct call to the write tool. An HTTP timeout or a displayed input prompt does not establish a durable approval gate.
Delegated identity: the shortcut the MCP spec forbids
Do not fix delegation by simply forwarding Priya’s inbound MCP token. The authorization security considerations prohibit token passthrough. An MCP server calling an upstream API acts as an OAuth client and needs a credential intended for that API.
The authorization specification requires the RFC 8707 resource parameter. It identifies the protected resource for the token request. Check the token’s audience at each hop rather than treating one sign-in as authority for every service.
The downstream credential may represent a workload or an authorized user. Some routes use token exchange. AWS’s outbound authorization guide describes the grants and target types it supports. Its on-behalf-of exchange can preserve user and agent identity; other grants may not.
RFC 8693 defines token exchange, including impersonation and delegation. Inspect the resulting identity and rights at the destination. Do not assume that every exchange preserves both the user and agent.
Workload identity federation across clouds
If the support agent and billing service run in different clouds, each destination still needs a supported trust and authorization configuration. ASCENDING describes its federation approach on the AgentCore and AI Foundry page. During evaluation, ask which provider, token type and connection mode the deployed version supports, then demonstrate the allowed and denied paths. Registering a remote agent is not proof of delegated access to every system that agent can call. The networking considerations are in why multicloud agentic workflows break.
Agent gateway vs API gateway, row by row: keep, extend, or add
Four checks give three decisions. Keep a control that already passes. Extend the current gateway where a supported plugin or integration closes the gap. Add a separate component where the existing path cannot meet the requirement. A workflow engine or downstream service may supply the missing control; adding a second gateway is not the only possible answer.
An MCP-aware plugin may close the gap without a second gateway. Kong’s AI MCP Proxy defines a default_acl and per-tool acl rules using consumer names, groups or claim values. Check the deployed plugin version and mode before relying on those rules.
Cost limits need their own test. Kong’s AI Rate Limiting Advanced reads LLM-response usage to limit prompt, completion or total tokens, or apply a cost strategy. Scopes include consumer, group, model and provider. Ask separately whether your chosen service meters A2A traffic. Request counts alone can miss the cost of retries that resend a growing history.
Screening is vendor-dependent. OWASP’s prompt-injection guidance describes a risk that one filter cannot eliminate. Some gateways integrate a classifier or guardrail service, but that is a configured capability with its own coverage and failure behavior. Review tool definitions, allowed operations and downstream authorization as separate controls; a passed content scan is not authorization to issue the refund.
Agent traffic controls: keep, extend, or add
| Control | Existing API gateway | MCP-aware plugin on that gateway | Protocol- and session-aware agent gateway | Verdict |
|---|---|---|---|---|
| Transport security and caller authentication | Native | Same | Same | Keep |
| Request-count rate limiting | Usually supported | Same baseline | Check per-user, agent and tool granularity | Keep as backstop |
| Tool-specific authorization | Requires suitable metadata/body policy or downstream enforcement | MCP-aware ACLs where supported | Verify the actual resource and action checks | Extend or add after testing |
| Token or dollar budgets | Requires usage-aware integration | Available for some LLM traffic; confirm scope | Vendor- and traffic-dependent | Verify metering, not the label |
| Audit evidence | Access logs plus configured instrumentation | Protocol fields depend on the plugin | Verify identities, tool, outcome, retention and missing fields | Collect and correlate evidence |
| Delegated identity | Depends on identity integration and destination | Check supported grants and claim handling | Check supported grants and downstream principal | Test both user and workload boundaries |
| Tool discovery filtering | Requires MCP-aware handling | Depends on the plugin | Depends on the implementation and connection mode | Test explicit calls separately |
| Prompt and tool-description screening | Check configured integrations | Check classifier/guardrail support and failure behavior | Check configured support; no complete injection guarantee | Vendor-dependent |
| Durable human approval | Usually coordinated with an application or workflow service | Check the integration | Not inherent in the gateway category | Test approval binding and retries |
When a second layer earns its place
One option is a protocol-aware layer for MCP or A2A endpoints, with the existing gateway retained for REST and GraphQL. AgentCore Gateway supports API Gateway REST APIs as targets, showing that layers can coexist. Use that shape only when the tests justify its extra controls and operating cost.
For Priya’s example, keep the current gateway if its supported plugin and billing service pass the required access tests. If the missing control is refund approval, identify a component that can store and enforce that approval. It may be the workflow engine or billing service. A new gateway is one possible response to a proven gap, not the automatic purchase decision.
Check the chosen service’s current quotas, supported transports, target types and timeout behavior before designing the chain. A long invocation timeout is not evidence of durable task storage, and caching a discovered tool list must not bypass a fresh execution-permission check.
The registry describes available resources; the gateway governs supported runtime calls; the orchestrator coordinates work. Those are distinct responsibilities even when one product packages them together. See enterprise MCP registry architecture, ASCENDING’s MCP gateway page and the MCP gateway evaluation guide for the corresponding boundaries.
The distinction becomes concrete in an insurance eligibility workflow: one operation retrieves payer evidence, while a separate operation proposes or writes a record update. A payer-call service can return its result later, after the original request has finished. Use these as evaluation cases for delegated identity, result correlation, and approval boundaries across both gateways.
When the gateway you already run is enough
Stay put if every tool looks like get_invoice and none like issue_refund:
- There is no Priya: agents hold their own service identity and never borrow a person’s.
- The catalog is yours: first-party servers, a handful of tools, changed only by your releases.
- Nothing is a refund: every tool reads, or writes something you can revert in seconds.
- One turn, one answer: no task waits on a person or another agent.
- Spend is throttled in the application; the gateway’s request counter is a safety net.
Re-evaluate the existing controls when one of these becomes true. Add another layer only if the current request path cannot meet the requirement:
- An agent acts for a named person against a system that records who did what.
- An MCP server in the catalog was written outside your organization.
- One tool moves money, deletes data, sends a message or changes infrastructure.
- A task outlives a request or hands off to another agent.
- An auditor may ask which tool ran, with which arguments, under which policy version.
Five questions to ask any agent gateway vendor
- Is a revocation in the registry refused on the next call, or after a sync?
- When an agent version is deprecated, when do callers stop reaching it?
- Does the audit record name the MCP tool and its arguments, or only the agent?
- Does it carry the policy snapshot in force, or only a policy ID?
- Does one gateway reach AWS AgentCore, Azure AI Foundry, Cloudflare MCP Server Portals and self-hosted servers, or is it one per provider?
Test one permitted call and one denied call before adding another layer
Use synthetic data and the same client configuration for each candidate. These are acceptance criteria, not claimed test results.
| Test | Evidence to retain | Why it changes the decision |
|---|---|---|
| Priya may look up an invoice but cannot issue a refund | Authenticated identity, operation, result and downstream observation | A shared endpoint must not turn read access into write access |
| An unauthorized identity knows the tool name | Explicit call is denied before the protected operation | Discovery filtering alone is insufficient |
| A grant is removed during an existing session | Saved permissions, timestamps and repeat-call outcome | Measure revocation behavior instead of assuming it |
| An approval expires or a request is retried | No unapproved write and no duplicate refund | A prompt or timeout is not a transaction control |
| An allowed call and denied call are investigated | Correlated gateway/service records with secrets redacted | A gateway log may not contain the downstream decision |
The MCP tool-call evidence checklist explains what to collect. Jarvis’s two-user access walkthrough provides a server-permission test and explicitly distinguishes it from per-user tool permissions and downstream record access.
Where Jarvis Registry fits, with the disclosure
Jarvis Registry is ASCENDING’s product and ASCENDING publishes this blog, so read this section as a vendor placing its own product in the table above, not as an independent assessment.
Jarvis Registry packages catalog and gateway functions. Its published access walkthrough distinguishes application-role capabilities from server ACLs: both are required for a protected server call. It also documents an important mode difference: server-wide disabled tools are enforced through execute_tool, but not by the transparent proxy. That switch is not a separate per-user tool grant.
For federation, use the deployed provider’s supported sign-in and sharing flow. Jarvis’s observability guide separates platform metrics from agent traces and requires backend setup. Ask which fields and denied calls your deployment records. A product-page description does not prove a complete policy snapshot, approval record or downstream audit trail. No cross-vendor or customer benchmark was run for this article.
Bring one delegated workflow, such as the refund above. Run its allowed, denied, revoked and approval-required cases with your identity provider before choosing. ASCENDING can help set up that proof of concept.
References
- Kong. “AI Gateway”.
- Kong. “MCP Traffic Gateway”.
- Kong. “AI MCP Proxy plugin reference”.
- Kong. “AI Rate Limiting Advanced plugin”.
- Linux Foundation. “Linux Foundation Welcomes agentgateway Project”.
- Solo.io. “agentgateway overview”.
- Model Context Protocol. “Streamable HTTP transport (2026-07-28 revision)”.
- Model Context Protocol. “Authorization (2026-07-28 revision)”.
- Model Context Protocol. “Authorization: Security Considerations (2026-07-28 revision)”.
- Model Context Protocol. “Elicitation (2026-07-28 revision)”.
- Microsoft Learn. “What are agent identities?”.
- Invariant Labs. “MCP Security Notification: Tool Poisoning Attacks”.
- AWS. “AgentCore Gateway: Core Concepts”.
- AWS. “AgentCore Gateway: Inbound Authorization”.
- AWS. “AgentCore Gateway: Outbound Authorization”.
- Jarvis Registry. “Validate MCP access with two users and synthetic data”.
- Jarvis Registry. “Observability”.
- Google Cloud. “Agent Gateway overview”.
- IETF. “RFC 8693: OAuth 2.0 Token Exchange”.
- OWASP GenAI Security Project. “LLM01: Prompt Injection”.
- A2A Project. “Agent2Agent (A2A) Protocol Specification”.
FAQ — Agent Gateway vs API Gateway
What is an AI agent gateway?
An agent gateway is a runtime entry point for supported agent or tool traffic. Products may add protocol-aware discovery, resource permissions, routing and observability to ordinary transport controls. The name does not guarantee delegated identity, per-tool budgets, durable human approval or complete audit records. Verify those capabilities on the deployed version and connection path; an existing API gateway with suitable extensions may already satisfy some of them.
Should MCP servers sit behind an existing API gateway at all?
They can. Keep useful TLS, authentication and traffic controls, then test MCP transport compatibility, tool-specific policy and streaming behavior. The current Streamable HTTP specification exposes method and tool metadata in headers, and MCP-aware extensions can add further controls. Neither ordinary proxying nor a product label proves that authorization, approvals and audit coverage meet your workflow's requirements.
Can an API gateway support delegated user identity?
Yes, if its identity integration and the downstream service support the required delegation flow. Distinguish the agent or workload from the person it acts for and verify the token's audience and permissions at the next service. MCP prohibits forwarding an inbound MCP token as an upstream API credential; a separately authorized downstream token is required. Token exchange is one supported design, not something every gateway performs automatically.
What is the difference between an MCP gateway, an agent gateway and an agent registry?
An MCP gateway handles MCP discovery or invocation traffic. An agent gateway may handle agent-to-agent interactions and additional protocols. A registry records resources, owners and sharing or lifecycle information. One product can package these functions together, but a catalog entry alone does not prove that a runtime call is authorized. Check the actual protocol, connection mode and resource permissions rather than relying on the category names.
Where does the agentic orchestration layer sit relative to the gateway?
The orchestrator coordinates steps and state; the gateway governs supported calls on their route to a resource. A sensitive action needs an approval check that cannot be bypassed through another route, plus safe handling of retries and expiry. That control may live in the workflow engine, tool service or an integrated gateway. Gateway presence alone does not make an approval binding.

