mrkeyoor.com_
Sun 01 Nov 15:12 UTC
AI Toolsevaluationupdated 01 Oct 2026

kong review

Kong Gateway sits between clients and APIs, LLM providers, or MCP servers, then routes traffic and applies shared rules. It handles jobs such as load balancing, authentication, rate limits, health checks, logging, and provider-specific AI traffic through configuration and plugins.

+31stars / 7d
Verdict

Our Kong fixture built in 22 seconds and passed all 6 tests, but those results cover a small Rust workspace rather than the running gateway. Put Kong on the shortlist when APIs, several LLM providers, and MCP servers genuinely need one policy boundary. Skip it for a single model integration, where the database choices, plugin testing, and gateway operations cost more attention than they save.

We ran it

Lab card: what happened when we ran kongScreenshot of kong (konghq.com/install)
Install✓ · 12s65 packages
Build✓ · 22s
Tests✓ · 9s6 passed · 0 failed of 6 (cargo test)
Repo2515 files~4,251 lines of source · 17 MB · 24 CI workflows · tests dir

Answers from our run

Does kong build from source?

Dependencies installed in 12 seconds (65 packages), and the build succeeded in 22 seconds. We cloned commit 8927af6 into a clean Debian container with 3 CPUs and no project-specific setup.

Do kong's tests pass?

Yes. The project's own test command finished in 9 seconds and reported 6 passed, 0 failed (cargo test).

Who should not use kong?

Teams treating a green Cargo run as proof that Kong itself works: our 6 passing tests covered only spec/fixtures/proxy_wasm_filters, not the Lua gateway.

What are the alternatives to kong?

Apache APISIX, Envoy Gateway, Portkey AI Gateway. Our Kong fixture built in 22 seconds and passed all 6 tests, but those results cover a small Rust workspace rather than the running gateway.

Setup3/5Fast fixture run, but the gateway needs a separate operating stack
Docs4/5Clear quick start and deep guides, split across several sites
Community5/544,231 stars with September pushes and October issue activity
Maturity5/5Long-running gateway with multiple deployment and upgrade paths

Discussed on

  1. hnKong 3.6 with LLM Support9 points

Who it’s for

Platform teams that already operate a shared API edge and want AI or MCP traffic governed there too.
Kubernetes operators who need gateway policy across many services rather than inside each application.
Organizations willing to test every chosen plugin and deployment mode against their own failure cases.
Kong users who can add LLM routing without introducing a separate gateway product.

Who it’s NOT for

Teams treating a green Cargo run as proof that Kong itself works: our 6 passing tests covered only spec/fixtures/proxy_wasm_filters, not the Lua gateway.
Small services wanting one process with no database or control plane: the recommended quick start clones a separate Compose repository, starts PostgreSQL, and exposes 3 management and traffic ports.
Source contributors who want a light build: Kong's developer guide calls source installation the hard route, uses a patched OpenResty stack, and requires GitHub authentication for dependencies.
Bedrock tool-calling deployments that cannot run a version-specific acceptance test: issue #14996 reports HTTP 500 on Enterprise 3.14.0.13 when a content block follows toolResult.
DB-less Kong 3.9 operators unable to restart a data plane during health-check trouble: issue #15001 reports recovered targets staying unhealthy until reload or restart.

Setup reality

In our September 30, 2026 sandbox, commit 8927af6 installed 65 packages in 12 seconds, built in 22 seconds, and finished cargo test in 9 seconds with 6 passed and 0 failed. The lab-rust:1 container was unprivileged and had 3 CPUs, 12 GB of RAM, and no secrets. The 17 MB checkout held 2,515 files and about 4,251 source lines. The measured project was the Rust fixture under spec/fixtures/proxy_wasm_filters, so this run did not start Kong Gateway.

The README's quick start clones Kong/docker-kong, starts a PostgreSQL profile with Compose, and exposes proxy, Admin API, and manager ports. Building this repository from source needs system packages, GitHub authentication for dependencies, a modified OpenResty environment, database bootstrapping, and deployment configuration.

Kong is mainly Lua on OpenResty, despite our harness selecting Rust. The checkout had 24 CI workflow files and a tests directory but no Dockerfile. Kong's own developer guide says integration tests need PostgreSQL and Cassandra, while plugin tests need PostgreSQL, none of which our fixture run exercised.

Kong puts API, LLM, and MCP policy in one request path

Kong Gateway can route ordinary API calls, normalize requests to several model providers, and govern MCP traffic. Its core jobs include load balancing, health checks, TLS termination, authentication, rate limits, transformations, and logs. The README also describes a universal LLM API plus MCP security and observability. That makes Kong interesting when a platform already has many clients and upstreams that should follow the same traffic rules.

The price is centrality. A bad route, plugin, or health policy can affect every caller behind it. Kong's README advertises more than 60 AI features, but a long feature list does not tell you which edition contains each requirement or how a chosen provider behaves during failure. Write down the routes, plugins, deployment mode, and edition before running a trial. Otherwise, a broad gateway evaluation turns into a tour of unrelated features.

The under-5-minute quick start is a separate Compose stack

Kong's README says its authentication test drive takes under 5 minutes. The first command clones Kong/docker-kong, not this repository, and the suggested Compose profile starts PostgreSQL. Traffic arrives on port 8000, the Admin API listens on 8001, and Kong Manager uses 8002. A DB-less Docker route is available, but it changes how configuration and recovery work. The short demo gets a gateway process running, not a production edge.

Source development is a different job. Kong says the application is mainly Lua on a modified OpenResty build with patched dependencies. Its Debian instructions install compilers and libraries, then require GitHub authentication to retrieve dependencies. The developer guide defines 3 Busted suites: unit, integration, and plugin tests. Integration needs PostgreSQL and Cassandra, while plugin tests need PostgreSQL. That is reasonable for gateway development, but it is much heavier than the Rust command our lab discovered.

What happened when we ran it

Our lab-rust:1 sandbox installed 65 packages in 12 seconds at commit 8927af6. The build passed in 22 seconds, and cargo test finished in 9 seconds with 6 passed and 0 failed. We used an unprivileged container with 3 CPUs, 12 GB of RAM, and no secrets. The checkout occupied 17 MB, contained 2,515 files and about 4,251 lines of source by the harness counter, and exposed 24 CI workflow files.

Those clean numbers belong to spec/fixtures/proxy_wasm_filters. Its Cargo workspace contains a tests member and a response-transformer member. The run did not boot OpenResty, start PostgreSQL, proxy a request, load a Kong plugin, call an LLM, or govern an MCP server. Our scan found a tests directory and no Dockerfile, which matches Kong's decision to keep its Docker distribution in another repository. Treat the 6 tests as evidence about one fixture only.

DB-less 3.9 has a reported health-check recovery trap

Open issue #15001 reports that targets on Kong 3.9 in DB-less mode can remain unhealthy after the backend recovers. The reporter describes a deterministic case where a health endpoint returns 404 and later returns 200, yet the target does not recover until a reload or restart. The same report says an Admin API attempt to mark it healthy returns HTTP 500 because targets are declarative in that mode.

This is one user's report, not a failure from our sandbox, and its intermittent 503 case was not reproduced on demand. The deterministic 404 path is still specific enough to test before adoption. Run the exact health policy you plan to ship, let an upstream return an unlisted status, restore it, and observe recovery without manual work. A DB-less design is appealing until its recovery path requires restarting the gateway in front of live traffic.

Bedrock tool calls have a current HTTP 500 report

Issue #14996 concerns Enterprise 3.14.0.13, not the 3.9.3 community release returned by GitHub's latest-release endpoint. The reporter sent a valid Bedrock Converse message where a content block followed toolResult. Kong returned HTTP 500 before calling Bedrock, while the same body sent directly to Bedrock returned 200. The issue includes a smaller control where toolResult alone succeeds.

That scope matters. It would be wrong to say every Kong AI route is broken, or that our 6 Rust tests found this defect. It is a sharp warning for one common agent pattern: tool use followed by more content. If Bedrock Converse is on your list, reproduce mixed content blocks, streaming behavior, prompt caching, and upstream error handling against the exact Kong edition and version you will deploy. Provider names on a feature page cannot replace that check.

September pushes and October issue work show active maintenance

GitHub recorded 44,231 stars, 221 open issues and pull requests, and a repository push on September 29, 2026. A separate issue search returned 87 open issues, so the larger number should not be called a bug count. Issue #14996 was updated on October 1. The latest non-prerelease returned by GitHub was 3.9.3, published June 17, which is less useful for judging health than the later code and issue activity together.

Our shortlist has 3 useful comparisons. Apache APISIX is the closest broad alternative here, Envoy Gateway fits teams standardized on Envoy and Kubernetes Gateway API, and Portkey is narrower for model traffic. Whichever route you take, make the trial fail on purpose: mix Bedrock tool content, strand a health-checked target, and take the database or control plane away. Kong earns its place only if your chosen setup recovers cleanly.

Alternatives

ProjectWhat it isPick it when
Apache APISIXAn Apache-licensed API and AI gateway built around Nginx and Lua.pick this instead when APISIX's plugin set and configuration model fit your existing edge better.
Envoy Gateway gh↗A standalone and Kubernetes gateway that manages Envoy Proxy.pick this instead when Gateway API and Envoy are already standard parts of your platform.
Portkey AI GatewayA gateway focused on routing, observability, and controls for model APIs.pick this instead when LLM traffic is the job and general API management would add unused surface area.

Sources

  1. Kong Gateway repository and README
  2. Kong developer guide at the measured commit
  3. Measured Kong commit 8927af6
  4. Kong 3.9.3 release
  5. Bedrock tool result HTTP 500 report
  6. DB-less active health-check recovery report

More ai tools reviews

anarlog · pr-agent · agent-sprite-forge · KiroCrew · Orkas · hypit · the whole board →