open-source prototype · MIT

Every gateway secures its own MCP. Nobody governs all of them.

Apigee, Azure APIM and Kong each turn their APIs into MCP tools. Forgegate reads the policies on all of them, shows what agents can actually reach, and fails CI when an estate ships without auth or rate limits.

# real output from examples/apigee in the repo
$ forgegate diff examples/apigee
Plan for petstore 3 (3 operations). Nothing will be written.

  GET    /pets          -> petstore_list_pets
      auth: apiKey (x-api-key in header)
      rate: 200/minute
  POST   /pets          -> petstore_create_pet
      auth: apiKey (x-api-key in header)
      rate: 10/second

$ forgegate validate examples/apigee
strict: 3 operations, no violations

Agents are reaching your APIs. Who checks the policy?

Each gateway vendor now ships a way to expose its APIs as MCP tools. That is good for one gateway. Large enterprises run several.

01

Three gateways, three stories

Apigee, APIM and Kong each have their own MCP feature, console and policy model. There is no single view of what is agent-exposed.

02

Policy fidelity is uneven

APIM's documentation says its policies apply to all operations exposed as tools in an MCP server, not to individual tools.

03

No shared audit or identity

Agent tool calls and delegated identity are logged in different shapes, if at all. Auditors ask one question; you answer it three ways.

Read the policy. Check it. Gate it.

Forgegate normalizes every source into one policy model, then works from that model.

INGEST

Real gateway artifacts

OpenAPI with annotations, Apigee proxy bundles (VerifyAPIKey, OAuthV2, Quota, SpikeArrest) and APIM policy XML.

CHECK

Dry-run and policy packs

diff shows which tools exist and which policy each inherits. validate applies the strict pack and exits non-zero in CI.

EMIT

Governed MCP server

Optional compile step produces a runnable server with inherited auth, client-side rate limits, OAuth2, an audit log and encoded path parameters.

Honest comparison with vendor-native MCP

If you run one gateway, use its native MCP feature. Forgegate is for the cross-gateway layer those features do not cover.

Vendor-native (Apigee, APIM, Kong, MuleSoft)Forgegate
Expose APIs as MCPYes, inside that vendor's platformOptional, via a generated standalone server
ScopeThat vendor's estate onlyOne policy model across sources
Per-tool policy viewVaries; APIM applies policy at server levelPer operation, shown in diff
CI gate on policy gapsNot a built-in conceptvalidate with policy packs
Cross-gateway drift detectionNoPlanned
MaturityShipping, supported productsEarly prototype

Why this matters: vendor features are the competition and the reason this exists. Forgegate is only worth using where more than one gateway is in play.

Where it stands

Working now

  • Apigee bundle exporter
  • Azure APIM policy exporter
  • OpenAPI with policy annotations
  • diff dry run and validate strict pack
  • OAuth2: delegated token and client credentials
  • Audit log, response labeling, path encoding
  • CI and 63 passing tests

Next

  • Kong exporter
  • Drift detection between gateway and agent-facing server
  • Token exchange (RFC 8693) for per-user delegation
  • Shared rate budgets across replicas
  • Cross-gateway audit schema

Early prototype. Not production-ready. Prompt-injection controls reduce risk but do not eliminate it. The repo's README states exactly what is and is not built.

MK

Manoj Kagitha

Cloud and API architect with Apigee X migration and multi-cloud API design experience. Building this in the open.

LinkedIn

Run forgegate diff on your estate.

Running more than one API gateway? I am looking for a handful of design partners for a 20-minute conversation. Read-only, no data leaves your machine.