Inferagate

Open-source AI gateway. Enterprise control when you need it.

Ship AI products without wiring models, keys, and guardrails by hand.

Inferagate gives companies one governed path for AI traffic: connect inference providers, discover models, route safely, apply guardrails, and inspect every request from a clean multi-tenant control plane.

Multi-tenant by design OpenAI-compatible API Runtime guardrails Provider catalog
Live gateway path tenant_482 / staging
Client app /v1/chat
REQ RES
Inferagate Route + guardrails
OK
Provider model selected
Routes draft -> simulate -> promote
Guardrails PII sanitized before runtime
Logs request, response, diff, audit
1 API for apps, OpenWebUI, SDKs, and internal tools
10+ runtimes hosted, local, self-hosted, and cloud inference
Every tenant isolated projects, environments, keys, providers, and logs

What it replaces

Stop spreading model logic across every product team.

Product leaders get one place to understand readiness, risk, and usage. Engineering teams get a stable OpenAI-compatible surface that does not change every time the provider stack changes.

01 Connect providers

Use presets for Ollama, vLLM, Bedrock, Hugging Face, OpenRouter, OpenAI, and more.

02 Expose model catalogs

Segment models by chat, embeddings, OCR, vision, video, code, local, or production use.

03 Route safely

Draft route changes, simulate fallback order, and promote only after review.

04 Investigate from logs

See request, response, guardrail decisions, redaction type, and original access audit.

Provider catalog

Connect the AI stack you already have, then add the stack you want next.

OpenAI Anthropic Bedrock Hugging Face OpenRouter vLLM Ollama Groq Mistral Together

For product teams

Know what is safe to launch

Readiness, route drafts, incidents, and guardrail coverage are visible without reading code.

For platform teams

Govern once, reuse everywhere

Projects, environments, service keys, and policy sets keep every app on the same operating model.

For developers

Keep the integration simple

Call one OpenAI-compatible endpoint and let the gateway handle provider choice, fallback, and logs.

For security

See what changed and why

Guardrail activity, payload diffs, redaction reasons, and original-payload access live in Logs.

Open-source core

Everything needed to run a real AI gateway.

  • Provider registry and OpenAI-compatible gateway API
  • Model discovery for supported provider catalogs
  • Routing, fallback, virtual keys, logs, and local runtime support
  • Developer-friendly setup scripts and Docker workflow

Enterprise controls

Add commercial controls when the deployment grows.

  • SSO, SCIM, workspace governance, and richer tenant controls
  • Route approvals, policy coverage, Splunk export, and support bundles
  • Production posture, readiness reports, and operational diagnostics
  • License-based upgrade path without changing the core gateway API

Developer documentation

Technical enough for builders. Clear enough for buyers.

Keep the homepage customer-friendly, but give engineers a direct path to the details they need before they trust a gateway in front of production AI traffic.

Developer handoff

One integration path from prototype to production.

Teams can start with a local provider, move to hosted inference, and keep the same app integration while platform owners control routes, keys, guardrails, and audit trails.

OpenAI-compatible request
curl https://gateway.example.com/v1/chat/completions \
  -H "Authorization: Bearer sk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "chat",
    "messages": [{ "role": "user", "content": "Summarize this contract" }]
  }'

Start small, keep the path to enterprise open

Create one workspace, connect one provider, and route your first AI request through Inferagate.