AI Gateway vs. Kong AI Gateway: AI traffic in your existing API gateway or a dedicated governance and FinOps component?

Key facts (as of 26 September 2026):

• Kong AI Gateway, per the vendor, extends the Kong Inc. API gateway to LLM, MCP and agent traffic; the Kong Gateway core is licensed under Apache 2.0, while per the documentation the AI Gateway product requires Konnect (SaaS control plane with data planes at the customer) or Kong Gateway Enterprise (fully self-managed).
• The innFactory AI Gateway is deployed into the customer’s cloud tenant and bundles cost centers with per-member caps, budgets in euros and a companion that measures the agent time of Claude Code, Codex and OpenCode per repository, including subscription usage.
• Per the documentation, Kong limits tokens or derived costs per consumer, consumer group, model or provider with HTTP 429 and measures what passes through the gateway; a local companion for agent time and subscription usage is not described in Kong’s documentation (as of 26 September 2026), whereas the innFactory AI Gateway ships cost centers with per-member caps, EUR display, HTTP 402 with an optional fallback model and the companion.
• Kong AI Gateway fits when you already run Kong as your API gateway and want to govern AI traffic with the same policies, plugins and deployment patterns, or bill AI usage to your own customers; the innFactory AI Gateway fits when control plane and data path should live entirely in your own tenant and agent time per repository and cost center should be visible.

Many IT departments have known Kong as an API gateway for years. According to its terms of use, Kong Inc. is headquartered in San Francisco, and by its own account it was founded in Milan in 2009, originally as Mashape. Kong AI Gateway extends that API platform to AI traffic; the vendor describes it as a “Secure, Scalable AI Gateway for AI Connectivity” and promises: “Govern LLM, MCP, and agent-to-agent (A2A) traffic with the same Kong AI Gateway.” It is a strong product on a mature foundation, and anyone who already runs Kong has good reasons to route AI traffic through the same infrastructure.

The real decision is therefore: do you treat LLM, MCP and agent traffic as one more protocol in your existing API gateway — or do you need a dedicated component for AI governance and AI FinOps that additionally sees the work of the coding agents on developer machines?

What Kong AI Gateway is

The Kong Gateway core is licensed under Apache 2.0 and, according to the repository, is “built on OpenResty (Nginx)” with Lua as its primary language. With Gateway 3.6, the vendor says it released six AI plugins as open source, including AI Proxy, AI Prompt Guard, AI Prompt Template and AI Prompt Decorator — “entirely free and open source for everyone”.

The AI Gateway product in the narrower sense is a separate matter: “AI Gateway is not part of open-source Kong Gateway. It requires Konnect for cloud deployments or Kong Gateway Enterprise for on-premises installations.” AI Proxy Advanced, AI Rate Limiting Advanced, AI Semantic Cache, AI Semantic Prompt Guard, AI Sanitizer and AI MCP Proxy carry the notice “only available as part of our AI Gateway Enterprise offering”. Context also includes the 2025 acquisition of OpenMeter, which Kong says it uses for “usage-based pricing, entitlements, and invoicing”.

Deployment model: SaaS, self-hosting or infrastructure in your own tenant

Kong offers three paths. You run Kong Gateway OSS yourself, with the open-source AI plugins. Kong Gateway Enterprise can, according to the documentation, be fully self-managed. Konnect is Kong’s SaaS control plane: you configure in the browser, the data planes run in your environment. According to the documentation, only configuration and telemetry travel between the planes; of the telemetry it says: “It does not include any customer data.” Prompts and responses therefore stay in the customer-operated data plane, while control sits with Konnect. For Kubernetes there is a Helm chart, and hybrid mode uses mTLS.

The innFactory AI Gateway is rolled out as a cloud-native infrastructure component into your own cloud tenant — Azure Container Apps or AKS as the reference path, STACKIT, or any Kubernetes — and operated there as part of your AI stack. innFactory does not host a SaaS variant; control plane, dashboard and data path all live in the tenant. innFactory GmbH, a Microsoft CSP, supports the rollout and can provide the Azure subscription. Configuration is YAML as code, plus a Terraform provider. The gateway has been in production with first customers since August 2026, currently at version 1.0.0-rc16.

Identity, SSO and roles

According to the documentation, Konnect supports “any OIDC or SAML-compliant provider”; Kong names Okta, Azure Active Directory, Oracle Identity Cloud Service and Keycloak as verified. The role model has organisation roles and resource-scoped roles (Admin, Viewer, Creator, Maintainer, Publisher), including scoping to AI Gateways; teams can be populated from IdP group claims. SCIM is not documented on the SSO page, and the page does not tie SSO to a particular Konnect tier either.

The innFactory AI Gateway connects to Microsoft Entra ID or a generic OIDC provider (Keycloak documented). There are seven roles — Owner, Admin, Auditor, Finance, Security, Member and Guest — group mapping from the IdP, dedicated administrators per cost center, and per-person allowed models, budgets and rate limits, in every license tier.

Cost control and AI FinOps

Kong’s cost control has two layers. In the gateway, AI Rate Limiting Advanced enforces: it “supports multi-dimensional limiting at the Consumer, Consumer Group, IP address, header, path, model, and provider levels”, works on a token basis and, since version 3.8, can compute costs when the administrator stores input and output prices per million tokens; when a limit is exceeded, the gateway answers with “HTTP/1.1 429”. On the platform side, Konnect promises to meter LLM traffic “down to the token, per model, per customer, per request”, to provide “hard and soft quotas, and automatic notifications” and to build “showback and chargeback for LLM, agent, and MCP usage”, up to invoices and ERP integration. Currency handling, a per-request cost header and a CSV export are not documented on the pages reviewed.

The innFactory AI Gateway treats cost as an object of its own rather than a rate limit. Four independent gates: organisation (monthly), cost center (monthly plus daily and weekly windows), user and API key. Cost centers run in pool or per-user mode, the latter with per-member caps that are always hard stops. When a budget is exhausted, the gateway answers with HTTP 402 (E4006) — or optionally redirects to a fallback model. Add per-model caps, TPM and RPM limits, alerts at 80 and 90 percent and a budget_exceeded event for webhooks. Prices come from ai-prices.eu, reviewed by the admin before they apply; display is in EUR at the ECB daily rate. Every buffered response carries the header x-aigateway-response-cost; Insights break usage down by user, model, repository, cost center or tool, with CSV export.

Coding agents, subscriptions and agent time

Under “AI CLIs”, Kong documents proxying Claude Code, Codex CLI and Qwen Code CLI. One cookbook describes “Claude Code SSO” with Okta and consumer-group-based model routing, another GitHub Copilot via its BYOK endpoint. What Kong measures is what passes through the gateway; attribution per repository is not documented, and OpenCode is not documented as a proxy target. According to Kong’s documentation (as of 26 September 2026), a local companion that captures agent time and subscription usage is not described.

The innFactory AI Gateway ships setup generators for Claude Code, Codex, OpenCode, Cowork, VS Code Continue and VS Code Copilot (BYOK), each with its own key and cost center per developer. The difference is the companion aigw: a small background service on the developer machine (Linux, macOS, Windows) that reads the local session logs of Claude Code, Codex and OpenCode and reports agent time, LLM time and token classes per repository, user, tool and cost center. It detects whether a session ran through the gateway or on the tool’s subscription (Claude Max, ChatGPT/Codex plan); subscription usage is valued at list price but never billed, budgeted or rate-limited. Rollout works via device-code login or enrollment tokens for Intune, macOS policy and Linux; aigw run launches the tool with a short-lived proxy token.

Providers, dialects and models

Here Kong is broader. The providers page names 19 vendors, including OpenAI, Azure AI, Amazon Bedrock, Gemini, Anthropic, Cohere, Hugging Face, Mistral, xAI, Databricks and vLLM; the plugin documentation lists 17. Inbound, AI Proxy accepts OpenAI formats by default and, since version 3.10, native formats for Anthropic, Bedrock, Cohere, Gemini, Vertex AI and Hugging Face. STACKIT and IONOS are not documented. We make no statement about realtime and audio endpoints because we could not retrieve the relevant reference as of this date.

The innFactory AI Gateway supports 13 provider types: OpenAI, Azure OpenAI, Azure AI Foundry, Anthropic (direct or Vertex), Gemini (AI Studio or Vertex including the EU endpoint), Mistral, AWS Bedrock, STACKIT, IONOS, Ollama, LM Studio, ElevenLabs and OpenAI-compatible endpoints. Inbound it speaks three dialects — OpenAI, Anthropic and Gemini — plus realtime WebSocket for OpenAI, Azure OpenAI, ElevenLabs and Gemini Live, as well as audio, embeddings, images and files/batches.

Governance: guardrails, MCP, routing and Flow Builder

Kong’s guardrails are spread across plugins: AI Prompt Guard with regex lists and a filter against invisible characters “that can hide prompt injection attempts”; AI Semantic Prompt Guard for semantic topic lists; AI Sanitizer, which according to the documentation anonymises sensitive data in request and response bodies; further plugins for external guardrail services are listed by name on the overview page. AI Proxy Advanced routes by latency, usage, priority or semantics, among others, with fallback across provider boundaries. AI MCP Proxy works as a “protocol bridge, translating between MCP and HTTP” in four modes, authenticates via OpenID Connect or Key Auth and uses tool ACLs to govern which consumers see which tools. A visual flow builder is not documented.

The innFactory AI Gateway bundles guardrails into nine rule types — secret detection, PII block or redaction, banned keywords, token and cost limit, Azure Content Safety, prompt injection, denied topics, groundedness and external webhook — with shadow mode, mid-stream redaction and a GDPR preset. The MCP proxy offers eight upstream auth modes (including Entra on-behalf-of and per-user OAuth PKCE), named toolsets, semantic tool search and guardrails on tool arguments and results. Routing covers an auto-router by prompt complexity, aliases, cross-provider fallbacks and deployment groups. The Flow Builder adds a visual graph with nine strategies, guardrail nodes with pass, block and fail branches, and event triggers to webhooks; a flow is callable like a model and bills the same budgets.

What Kong AI Gateway does better

• API and AI in one control plane. According to the vendor, policies and visibility span all APIs and LLMs; existing plugins for AuthN/Z and traffic control apply to AI traffic as well. Kong cites more than 100 enterprise plugins.
• Deployment maturity. Helm chart, Kubernetes installation, hybrid mode with mTLS, and according to the vendor also VM and bare metal.
• Secret manager integrations. HashiCorp Vault, Azure Key Vault and AWS Secrets Manager are named.
• Provider breadth, semantic caching and routing. 17 to 19 providers, native formats for Cohere and Hugging Face, AI Semantic Cache on Redis, pgvector or Valkey.
• Metering and billing towards your own customers, according to the vendor up to invoicing and ERP integration.
• A2A. Alongside LLM and MCP, Kong also lists agent-to-agent traffic.
• Support. According to the vendor, a “24/7/365 globally distributed support team along with professional services”.

When Kong AI Gateway is the right choice

• You already run Kong as your API gateway and want to govern AI traffic with the same policies, plugins and deployment patterns.
• You need providers we do not offer as a dedicated provider type, such as Cohere, Hugging Face, Databricks or Amazon SageMaker.
• You want to meter and bill AI usage to external customers.
• A SaaS control plane with your own data planes fits your requirements, or you run Kong Gateway Enterprise self-managed anyway.

When the innFactory AI Gateway is the right choice

• You want control plane and data path entirely in your own tenant, with no SaaS component.
• You need cost centers with pool or per-user budgets, per-member caps, EUR display and a fallback model instead of a hard rejection.
• You want to see agent time and subscription usage of Claude Code, Codex or OpenCode per repository and cost center — even where no gateway is in the path.
• You need STACKIT, IONOS or realtime endpoints behind a gateway.
• You use CompanyGPT and want to maintain identity, budgets, guardrails and the MCP registry only once.

Comparison at a glance

Conclusion

Kong AI Gateway is the consistent answer of an API management vendor to AI traffic: if you have Kong, you get LLM, MCP and agent traffic in the same control plane, with the same plugin model, the same deployment maturity and a metering layer that reaches all the way to the invoice. For platform teams with Kong experience, that is a convincing path.

The innFactory AI Gateway is cut differently: a dedicated governance and FinOps component entirely in the customer’s tenant, with cost centers, per-member caps, EUR display and a companion that also captures the work of coding agents that never passes through a gateway. Which answer fits depends on whether AI traffic is, for you, one more protocol or a governance topic in its own right.

Natively integrated with CompanyGPT, one reusable stack

The AI Gateway is natively integrated with CompanyGPT: the same budgets, cost centers and guardrails apply to chat, agents and add-ons. Identity via Entra ID or Keycloak, cost centers, guardrails and the MCP registry form one stack that is reused across CompanyGPT, the gateway and your own applications. The gateway can equally run standalone. Details are on the AI Gateway page, with further comparisons under all comparisons.

Sources

Retrieved on 26 September 2026:

• Kong AI Gateway product page — https://konghq.com/products/kong-ai-gateway
• Kong terms of use (headquarters) — https://konghq.com/legal/terms-of-use
• Kong company page (founding, acquisitions) — https://konghq.com/company
• Kong AI Gateway documentation (tier notice) — https://developer.konghq.com/ai-gateway/
• Kong Gateway repository (license, architecture) — https://github.com/Kong/kong
• Announcement of Kong AI Gateway and open-source plugins — https://konghq.com/blog/product-releases/announcing-kong-ai-gateway
• AI Proxy plugin — https://developer.konghq.com/plugins/ai-proxy/
• AI Proxy Advanced plugin — https://developer.konghq.com/plugins/ai-proxy-advanced/
• AI Rate Limiting Advanced plugin — https://developer.konghq.com/plugins/ai-rate-limiting-advanced/
• AI Semantic Cache plugin — https://developer.konghq.com/plugins/ai-semantic-cache/
• AI Prompt Guard plugin — https://developer.konghq.com/plugins/ai-prompt-guard/
• AI Semantic Prompt Guard plugin — https://developer.konghq.com/plugins/ai-semantic-prompt-guard/
• AI Sanitizer plugin — https://developer.konghq.com/plugins/ai-sanitizer/
• AI MCP Proxy plugin — https://developer.konghq.com/plugins/ai-mcp-proxy/
• Konnect network (control plane and data plane) — https://developer.konghq.com/konnect-platform/network/
• Kong Gateway on Kubernetes (on-prem) — https://developer.konghq.com/gateway/install/kubernetes/on-prem/
• Kong Helm charts — https://github.com/Kong/charts
• Konnect SSO — https://developer.konghq.com/konnect-platform/sso/
• Konnect teams and roles — https://developer.konghq.com/konnect-platform/teams-and-roles/
• Konnect usage-based metering and billing — https://konghq.com/products/kong-konnect/features/usage-based-metering-and-billing
• Kong AI Manager announcement — https://konghq.com/blog/product-releases/kong-ai-manager
• AI CLIs (Claude Code, Codex CLI, Qwen Code CLI) — https://developer.konghq.com/ai-gateway/ai-clis/
• Kong cookbooks — https://developer.konghq.com/cookbooks/
• GitHub Copilot BYOK cookbook — https://developer.konghq.com/cookbooks/github-copilot-byok/
• AI providers — https://developer.konghq.com/ai-gateway/ai-providers/
• Kong AI Gateway alternatives (plugins, secret managers, support) — https://konghq.com/performance-comparison/ai-gateway-alternatives

Note on the information: All statements about other vendors’ products are based on their publicly available documentation as of the stated date. Vendors continuously develop their products, features and terms — the vendor’s current information always prevails. If any statement appears outdated or incorrect to you, please drop us a line at info@innfactory.ai; we will review and correct it promptly. This comparison does not replace legal or data-protection advice in individual cases.

Further reading

• AI Gateway – governance, FinOps and companion at a glance
• CompanyGPT – the platform the gateway is natively integrated with
• Claude Code as an AI harness – what the coding agent can do and how it runs through the gateway
• AI harness explained – fundamentals of AI agents and harnesses
• All AI Gateway comparisons – LiteLLM, OpenRouter, Portkey, Cloudflare, Kong, Bifrost, TrueFoundry, Helicone, Vercel
• AI Gateway vs. LiteLLM
• AI Gateway vs. Bifrost (Maxim AI)
• AI Gateway vs. Helicone