Best AI Gateways for Multi Model Apps 2026

LiteLLM is the best overall AI gateway for a multi-model app when a platform owner can run it; Vercel AI Gateway is the best managed default. The reported $8 billion-plus agreement for Stripe to acquire OpenRouter makes the deciding requirement plain: your production app needs a gateway it can bypass without a rewrite.

Axios reported on 17 August 2026 that Stripe had agreed to acquire OpenRouter for more than $8 billion in cash and stock. Axios also said the companies had not commented and an official announcement was still expected. That distinction matters, but the operating lesson does not depend on the deal closing: a gateway removes model-vendor lock-in only if it does not become the next lock-in.

The short answer: which AI gateway should you choose?

Choose LiteLLM for control, Vercel AI Gateway for managed simplicity, Portkey for enterprise governance, and OpenRouter only when catalog breadth is worth a percentage fee and an extra vendor dependency. An AI gateway is the request layer between your application and model providers. It can normalize APIs, hold credentials, route traffic, retry failures, record costs, and enforce policy.

Prices and product limits below were verified against each vendor's live pages on 18 August 2026. The ranking covers 10 products, with each choice judged on the production wall a buyer will hit rather than on how many feature labels fit on a card.

The first decision is not feature count. It is who owns the request path. A self-hosted gateway keeps the process, credentials, database, logs, and policy in your environment, but it gives your team the pager. A managed gateway removes that operating burden, but its outage, pricing change, acquisition, and product roadmap now sit inside every model call.

The cost boundary is clearer than the feature pages make it look. Assume a self-hosted gateway consumes eight platform hours per month at a fully loaded $150 per hour. That is an illustrative $1,200 monthly operating cost, not a vendor quote. A 5.5% gateway fee reaches $1,200 at $21,818 of monthly model spend; a 5% fee reaches it at $24,000.

That calculation is only the budget line. A deployment boundary, regulated data path, provider contract, or required audit trail can justify self-hosting well below the financial break-even. Conversely, a small startup should not create an internal platform job to save a fee worth less than one engineer-day.

Why the gateway is now a budget line and an exit plan

A gateway is valuable because models change quickly, but it is dangerous when the application can no longer run without that gateway. The OpenRouter report arrives less than three months after Palo Alto Networks closed its acquisition of Portkey and said Portkey would become a core part of Prisma AIRS. Two independent control planes can move into larger platforms in one quarter. Buyers should expect ownership changes in this category, not treat them as edge cases.

The business consequence is concentration. A multi-model application may call OpenAI for one workflow, Anthropic for another, and an open model for a high-volume background job. Putting all three behind one gateway simplifies code, billing, policy, and observability. It also means one pricing or policy change can touch all three at once.

The safe pattern has three layers:

• An internal model client defines the small set of operations your app needs, such as text generation, structured output, embeddings, and tool use.
• A gateway adapter maps those operations to the selected gateway without leaking gateway-specific headers through the rest of the codebase.
• A direct-provider adapter remains configured and documented, even if it carries no normal production traffic.

That structure creates what this guide calls the 10-minute exit: an operator should be able to route one production workload around the gateway through configuration and a controlled deploy, without changing business logic. Ten minutes is an editorial operating target, not a vendor SLA. If bypassing the gateway requires a client rewrite, new identity design, or a migration of every model name, the gateway owns more of the application than the model providers do.

This is also why a feature such as automatic fallback needs scrutiny. A fallback is useful only when it preserves the response protocol, tool schema, data policy, and cost boundary the application expects. A successful HTTP response from a different model can still be an application failure if its structured output changes or its tool call is incompatible.

For a deeper look at the inference layer beneath the gateway, the cheapest AI API comparison separates model price from the routing fee. If the immediate use case is developer tools rather than a customer-facing application, the narrower AI gateways for coding agents guide covers coding-agent setup and repository attribution.

How these AI gateways were picked

The ranking rewards reversibility and operating fit before model count. A catalog of hundreds of models is useful during discovery and mostly irrelevant after a production application standardizes three approved routes.

Each gateway was judged on five criteria:

1. Portability: Can the app keep its own provider accounts, model names, policy, and direct route?
2. Deterministic resilience: Can operators control retries, provider order, fallback behavior, and the conditions that stop a request?
3. Cost visibility: Can spend be attributed to an application, customer, team, or key, and can the fee be predicted from public pricing?
4. Governance boundary: Can the gateway meet the deployment, identity, retention, audit, and data-residency requirements of its buyer?
5. Operational maturity: Is the gateway generally available, supportable, observable, and priced for the stage at which it will be used?

The work here was pricing-and-documentation verification, not a disguised product trial. No claim of live deployment, load testing, or subscription is made. Every tier, limit, and specific capability comes from a vendor page opened on 18 August 2026; the cost comparisons are arithmetic applied to those inputs.

The field was narrowed to products that can sit in the request path of a multi-model app today. A single-cloud model catalog can still be the right platform, but it is not neutral routing. A product that exists only on a roadmap cannot be ranked above a gateway a buyer can deploy and price now.

1. LiteLLM: best overall for an app-owned control plane

LiteLLM is the best overall AI gateway when a named platform owner can operate it. The open-source proxy puts 100+ providers behind one OpenAI-compatible API and includes virtual keys, teams, spend tracking, budgets, rate limits, fallbacks, request and response logs, and Prometheus metrics.

Best for: Product companies that require a self-hosted, app-owned gateway
Standout: Broad provider support with budgets, keys, fallbacks, and metrics in the $0 OSS plan
Pricing: Open Source $0; Enterprise annual and custom by capacity, architecture, and support
Free trial: 30-day Enterprise trial with no credit card; OSS remains free

LiteLLM's live pricing page makes the software boundary explicit. Open Source is free for production self-hosting. Enterprise is not token-priced; it is quoted annually from request capacity, deployment architecture, and support needs. Enterprise adds SSO and SCIM, OIDC or JWT authentication, audit logs, secret-manager integrations, key rotation, a multi-region control plane, air-gapped deployment, and support up to 24/7.

The $0 label is accurate and incomplete. Your team owns the proxy, Postgres, secrets, scaling, upgrades, provider API changes, log storage, dashboards, and incidents. Under the illustrative eight-hours-at-$150 assumption, that ownership costs $1,200 per month before infrastructure. LiteLLM becomes the financial winner over a 5.5% fee above $21,818 in monthly model spend, but a regulated deployment may choose it much earlier for control rather than savings.

The documented Docker quickstart starts the gateway and Postgres with curl -sSL https://docs.litellm.ai/docker-compose.yml | docker compose -f - up -d, then exposes the admin UI on port 4000. That is a useful evaluation path, not a complete production design. The same guide warns that the placeholder LITELLM_SALT_KEY must be replaced before adding persistent credentials and must not later change, because provider keys encrypted with the old value cannot be recovered with a new one.

The production wall is ownership ambiguity. LiteLLM is an excellent platform component and a poor side project. If the proxy belongs to "whoever added it," a provider change can turn one application engineer into the gateway team without budget, on-call coverage, or upgrade policy.

1. 1

   Start with a disposable deployment

   Use the documented Docker Compose quickstart in a non-production account. Confirm the gateway and Postgres start, replace placeholder secrets, and keep this environment separate from customer traffic.

2. 2

   Expose two named routes

   Add only the primary model and one compatible fallback. Use stable internal aliases such as support-primary and support-fallback so application code does not depend on every provider's public model string.

3. 3

   Issue an application virtual key

   Create a virtual key for one service, with its own model access, monthly budget, and rate limit. Do not distribute the LiteLLM master key to application workloads.

4. 4

   Keep a direct adapter

   Configure the same service to call the primary provider directly through a feature flag. The gateway route is the default; the provider route is the tested bypass.

5. 5

   Force the primary to fail

   Trigger a controlled unavailable route, confirm the fallback is visible in logs, then activate the direct adapter and time the switch. If the bypass cannot meet the 10-minute exit target, fix the abstraction before adding traffic.

2. Vercel AI Gateway: best managed default

Vercel AI Gateway is the best managed default for a product team that wants one endpoint without a token markup. Its routing controls cover provider filtering, ordering, model fallbacks, and provider choice informed by recent uptime and latency.

Best for: Startups and product teams that value fast managed adoption
Standout: Provider list-rate tokens with zero gateway markup
Pricing: Free includes $5 monthly credit; Paid uses purchased credits at provider list rates
Free trial: Ongoing Free tier on eligible models, with lower per-model limits

The current pricing page separates the free and paid states cleanly. Free includes $5 of credit each month. Purchasing credits moves the account to Pay as you go, opens all available models, raises limits, and ends that monthly $5 credit. Both tiers use provider list rates with zero token markup.

Bring Your Own Key is available only after the account moves to Paid. Vercel charges no gateway fee on BYOK, but a failed request using your credential may retry with Vercel system credentials and charge that fallback against the gateway credit balance. That behavior improves availability and can violate a finance assumption that all usage stays on an existing provider contract. Review it before using BYOK as a procurement shortcut.

The token layer is free of markup; some controls are not. Custom Reporting costs $0.075 per 1,000 writes and $5 per 1,000 reporting queries. A team-wide provider allowlist costs $0.10 per 1,000 successful requests, while a request-level only filter costs nothing extra. Team-wide zero data retention also costs $0.10 per 1,000 requests. Trace drains cost $0.05 per 1,000 traces plus $0.50 per GB of egress.

At one million requests, enabling the team-wide allowlist, team-wide ZDR, and one trace per request adds $250 plus trace egress. That is still modest beside model spend for many apps, but "zero markup" should not be translated into "every control is free."

The wall is deployment ownership. Vercel manages the gateway; you do not run its data plane inside your own cluster. Choose it when the managed boundary is acceptable and operational speed matters. Choose LiteLLM or Bifrost when private deployment is a requirement rather than a preference.

3. Portkey: best for managed enterprise governance

Portkey is the best managed choice when policy, guardrails, budgets, and private deployment options form the purchase case. Its gateway combines a universal API with retries, timeouts, fallbacks, load balancing, caching, virtual keys, and observability.

Best for: Mid-market and enterprise teams buying managed governance
Standout: Public production tier plus an Enterprise path for private cloud and VPC hosting
Pricing: Open Source self-hosted; Developer $0; Production $49/month; Enterprise custom
Free trial: Developer is free forever for prototypes and evaluation

The pricing page is unusually direct about the boundary between tiers. Developer records 10,000 logs per month, keeps logs for three days, keeps metrics for 30 days, and is explicitly not suitable for production. Production costs $49 per month, includes 100,000 recorded logs, charges $9 for each additional 100,000 up to three million, keeps logs for 30 days, and keeps metrics for 90 days.

At one million recorded logs, Production costs $130 per month: the $49 base plus nine $9 overage blocks. That remains approachable for a growing app. The same page says Production is not recommended when custom security controls or data-residency guarantees are required. Those buyers move to Enterprise, with 10 million-plus recorded logs, custom retention, SSO, granular budgets and limits, private cloud, VPC hosting, data-lake exports, and advanced compliance.

The product wall is not capability. It is purchase scope. A startup that only needs a base URL and fallback pays for less organizational value than Portkey is designed to provide. A platform team with several applications, approved-model policy, PII controls, and audit requirements can use the same features every week.

Ownership deserves a procurement question. Palo Alto Networks closed its Portkey acquisition on 29 May 2026 and said Portkey would become a core AI Gateway for Prisma AIRS. That can strengthen security integration and enterprise support. It can also change packaging and roadmap priorities. Ask which product name appears on the contract, how standalone accounts map to Prisma AIRS, and which export path survives a future consolidation.

4. Cloudflare AI Gateway: best low-cost edge control

Cloudflare AI Gateway is the best low-cost choice when Cloudflare already owns the application's edge, security, or Workers runtime. Core analytics, caching, and rate limiting are free on every plan.

Best for: Apps already using Cloudflare's network and security controls
Standout: $0 core gateway with free DLP scanning
Pricing: Core $0; Unified Billing credit purchases add 5%; guardrails use Workers AI pricing
Free trial: Core features remain free rather than expiring

Cloudflare's live pricing documentation gives the free offer concrete storage boundaries. Workers Free stores 100,000 logs across all gateways in the account. Workers Paid stores 10 million logs per gateway. DLP scanning is free, although an account without a Zero Trust subscription receives only two predefined DLP profiles. Guardrail evaluation is billed separately as Workers AI token inference.

Unified Billing charges 5% when you purchase credits, while third-party inference prices pass through without token markup. At $20,000 in monthly purchased credits, the fee is $1,000. The 5% line applies to credits purchased through Unified Billing, not to the $0 core gateway.

There is a throughput boundary worth catching before launch. The current limits page caps Unified Billing traffic at 200 requests per 60 seconds per gateway and returns a 429 above that rate. The limit does not apply to BYOK traffic. Cloudflare also limits stored logs to 500 per second per gateway, cacheable requests to 25 MB, cache TTL to one month, and custom metadata to five entries per request.

The wall is surrounding-platform fit. Cloudflare is compelling when the team already knows its account model, logs, DLP, Workers, and edge behavior. It is less compelling when adopting those concepts only to avoid a $49 gateway subscription. The cheapest listed gateway can create the larger integration bill.

5. OpenRouter: best model marketplace, not the safest sole route

OpenRouter is the best gateway when model and provider breadth are still the open questions. Its Pay-as-you-go plan lists 400+ models across 80+ providers behind one account.

Best for: Fast model discovery, provider comparison, and broad catalog access
Standout: Fine-grained provider routing by price, throughput, latency, policy, and availability
Pricing: Free $0; Pay as you go 5.5% platform fee; Enterprise custom with discounts
Free trial: Free tier with 25+ models, 4 providers, and 50 requests per day

The live pricing page lists three tiers. Free exposes 25+ free models from four providers at 50 requests per day. Pay as you go adds 400+ models, 80+ providers, high global limits, and no minimum spend, with a 5.5% platform fee. Enterprise keeps the catalog, adds fee discounts, invoicing, SSO or SAML, contractual SLAs, and a support SLA with shared Slack.

BYOK changes the fee boundary. Pay as you go includes $25,000 of list-price inference per month without a BYOK fee, then charges 5%. Enterprise raises that allowance to $200,000, then charges 5%. A buyer with direct provider commitments should model the BYOK allowance separately from purchased OpenRouter credits.

Routing depth is OpenRouter's strength. Its provider-selection documentation says the default avoids providers with significant outages in the prior 30 seconds, then weights stable low-cost providers by inverse-square price and uses remaining providers as fallbacks. Operators can instead sort by price, throughput, or latency; order named providers; disable fallbacks; require parameter support; deny providers that collect data; require zero-data-retention endpoints; or cap price.

Those controls can improve both uptime and economics. They also make default behavior part of the production contract. If your application requires structured output or tool use, set require_parameters and an allowlist rather than assume every endpoint under a model slug behaves identically.

At $20,000 of purchased credits, 5.5% is $1,100 per month. That is still below the illustrative $1,200 monthly self-hosting cost. The percentage keeps scaling after the operating burden of a stable self-hosted gateway may flatten, so the comparison should be revisited as spend crosses $21,818.

The reported Stripe agreement raises the cost of dependency, not a reason for a panic migration. OpenRouter remains the broadest marketplace choice in this ranking. The prudent response is a direct-provider adapter, exported policy, and a tested bypass. The full OpenRouter pricing analysis goes deeper on the fee and BYOK boundaries.

6. Bifrost: best OSS alternative for explicit retry control

Bifrost is the best open-source alternative when the team wants explicit retry behavior, OpenTelemetry, and a smaller gateway surface. The OSS tier is free forever and can run as a Docker deployment, Kubernetes workload, or Go binary.

Best for: Platform teams that want self-hosting with transparent resilience controls
Standout: Nested retry and fallback behavior with a per-request routing trail
Pricing: OSS $0; Enterprise custom
Free trial: 14-day Enterprise trial

The Bifrost pricing page places a single OpenAI-compatible API for 1,000+ models, OTel metrics and traces, observability, virtual-key budgets and limits, custom routing, automatic fallbacks, caching, and an MCP gateway in OSS. Enterprise adds VPC, on-prem, and air-gapped deployment; cluster mode; adaptive load balancing; SAML and OIDC; vault integrations; audit logs; RBAC; and SLA-backed support.

Bifrost's retry and fallback documentation is unusually specific. Network errors and 5xx responses retry the same provider. Rate limits and per-key failures can rotate credentials. Only after the primary exhausts its retry budget does the request move to the next fallback, and every fallback receives its own full retry budget.

That clarity exposes the wall: retries can multiply. A primary with three retries and two fallbacks that each have three retries can produce up to 12 attempts before returning an error. For an interactive app, that can turn a provider incident into a latency incident and a higher bill. Set a total latency budget and make security or compliance errors stop the chain rather than fail open.

Bifrost competes most directly with LiteLLM. LiteLLM wins on ecosystem familiarity and the breadth of its established control plane. Bifrost wins when its Go-native footprint, explicit routing trail, or retry semantics fit the platform team's operating model better. Both lose when no one is funded to own the proxy.

7. Helicone: best observability-first gateway

Helicone is the best choice when debugging sessions and explaining spend matter as much as routing. It combines a zero-markup gateway with observability, caching, rate limits, automatic fallbacks, prompt management, and request search.

Best for: Teams whose largest pain is understanding production model behavior
Standout: Gateway traffic lands directly in an observability and debugging product
Pricing: Hobby free; Pro $79/month; Team $799/month; Enterprise custom
Free trial: 7 days on Pro and Team

The pricing page makes the upgrade triggers visible. Hobby includes 10,000 requests, 1 GB storage, one seat, one organization, seven-day retention, and 10 logs per minute. Pro costs $79 per month, includes unlimited seats, one organization, one-month retention, 1,000 logs per minute, and 10 API calls per minute, with usage pricing beyond the included request and storage levels.

Team costs $799 per month and moves to five organizations, three-month retention, 15,000 logs per minute, 60 API calls per minute, SOC 2 and HIPAA support, and a dedicated Slack channel. Enterprise is custom and adds unlimited organizations, forever retention, 30,000 logs per minute, 1,000 API calls per minute, SAML SSO, on-prem deployment, and custom commercial terms.

The platform documentation describes two operating modes: pass-through credits across 100+ models at zero markup, or BYOK for teams that keep provider billing. Both preserve request-level observability. That is Helicone's advantage over a thin proxy. A failed user interaction can be traced across a session rather than reduced to a provider error count.

The wall appears immediately on Hobby. Ten logs per minute is enough to inspect a prototype and too low for many live applications. Pro's 1,000 logs per minute is the first realistic production boundary for moderate traffic. The buyer is choosing an observability plan and a gateway together, so compare the combined value rather than treating the routing layer as free.

8. Braintrust Gateway: best when evaluations decide releases

Braintrust Gateway is the best fit when traces must become evaluations, datasets, scores, and release checks. The gateway supports OpenAI, Anthropic, Google, AWS, and other providers through a unified API with caching, observability, and multi-provider support.

Best for: AI product teams whose routing changes are governed by evaluation results
Standout: Gateway traces connect directly to an evaluation platform
Pricing: Starter $0; Pro $249/month; Enterprise custom; hosted Gateway free during beta
Free trial: Starter needs no credit card; Gateway is free while in beta

Braintrust's platform pricing starts with Starter at $0. It includes 1 GB of processed data, then $4 per GB; 10,000 scores, then $2.50 per 1,000; 14-day retention; and unlimited users, projects, datasets, playgrounds, and experiments. Pro costs $249 per month with 5 GB of processed data, then $3 per GB; 50,000 scores, then $1.50 per 1,000; and 30-day retention, with additional retained data billed at $0.50 per GB per month. Enterprise is custom.

The gateway itself has a different status. Braintrust's Gateway documentation says the hosted endpoint is beta and free to use, with pricing to be announced before general availability. The global endpoint uses DNS latency routing and health checks across hosted regions. Logging can write gateway traces into the organization's configured data plane.

That integration changes the buying case. If a team samples production traces, scores responses, creates regression datasets, and blocks releases when quality drops, the gateway removes instrumentation steps and keeps evidence attached to traffic. If the team only needs retries and spend caps, the $249 Pro platform is difficult to justify against a simpler gateway.

The wall is future price and beta status. A free beta can be production-designed while still lacking a stable commercial meter. Use it with a direct-provider bypass, set an internal price ceiling before GA, and do not let a temporary $0 gateway price decide a permanent architecture.

9. Requesty: best simple percentage-priced control plane

Requesty is the best percentage-priced managed option for a small team that wants routing, caching, fallbacks, budgets, and EU data residency without a subscription. Pay as you go exposes 600+ models across 20+ providers.

Best for: Startups that prefer a fee tied directly to model usage
Standout: No subscription, seat fee, minimum spend, or separate charge for core routing controls
Pricing: Free $0; Pay as you go adds 5%; Enterprise custom
Free trial: Free tier with 200 requests per day on free models, no card

The pricing page gives Free 200 requests per day on free models, plus routing, caching, fallbacks, spend analytics, and EU data residency. Pay as you go charges a 5% markup on base model costs and includes BYOK, routing policies, caching, fallbacks, spend limits, an MCP Gateway, advanced observability, and email support. Enterprise adds SSO, RBAC, audit logs, approved-model policies, team budgets, guardrails, PII detection, service accounts, dedicated support, and custom SLAs.

The percentage makes early budgeting simple. At $2,000 in model spend, the fee is $100. At $20,000, it is $1,000. At $24,000, it equals the illustrative $1,200 monthly self-hosting cost. A startup can avoid a platform project while traffic is uncertain, then reopen the decision when usage stabilizes.

The wall is the same simplicity. The fee scales with model spend even if the gateway's operating work does not. A company with high token spend, a platform team, and existing provider contracts should compare Requesty's Enterprise quote or a self-hosted proxy before accepting 5% indefinitely.

Requesty ranks below Helicone because its strongest case here is efficient managed control rather than a differentiated production evidence loop. It can still be the better purchase when no subscription and a predictable percentage matter more than deeper evaluation or enterprise policy.

10. Kong AI Gateway: best for an existing Kong estate

Kong AI Gateway is the best choice when Kong already governs the company's APIs and AI traffic should inherit that operating model. Plus includes a universal LLM API, up to five unique proxied models, unlimited agent-to-agent traffic, unlimited MCP server proxies, PII sanitization, guardrails, access control, token rate limits, semantic caching, and cost analytics.

Best for: Enterprises already running Kong Konnect or Kong Gateway
Standout: AI policy inside a broader API, identity, portal, and service-governance platform
Pricing: 30-day trial $0; Plus usage-priced; Enterprise custom annually
Free trial: 30 days with no credit card and no gateway limits

Kong's live pricing page exposes the Plus meters. A Serverless control plane costs $25 per month, Hybrid costs $200, and Dedicated Cloud costs $500 plus $0.15 per GB. Plus includes one million API requests, then charges $200 per additional million up to a 10 million monthly maximum.

AI model proxying costs another $100 per month for each unique LLM model, with a limit of five on Plus. A four-model app on one Serverless control plane therefore starts at $425 per month before model tokens: $25 for the control plane plus $400 for the four model proxies. Paid AI plugins are separate add-ons on Plus and included in Enterprise.

Enterprise removes gateway and model limits, supports fully self-hosted API gateways, and adds audit logs, SSO, dedicated support, professional services, and higher SLAs. Pricing is custom and billed annually.

The wall is platform weight. Kong makes sense when API governance, control planes, identity, analytics, service catalog, and support already exist in the budget. For a greenfield multi-model app, paying by control plane, model, and request adds concepts before the product has proven it needs them. Vercel, Cloudflare, Requesty, or an OSS proxy gets to a smaller decision faster.

Who should pick what?

Pick from the constraint that would stop the launch, then compare fees. Routing sophistication does not compensate for the wrong deployment boundary, and a low fee does not compensate for missing audit or rollback controls.

Choose Vercel AI Gateway for a startup shipping a customer-facing app with a small approved model set and no private-deployment requirement. The choice flips to Cloudflare when Cloudflare already owns the edge and security layer, or to Requesty when a 5% usage fee is easier to fund than a platform subscription.

Choose LiteLLM for a product company with a platform owner, existing container and database standards, and either a hard data-path requirement or monthly model spend moving beyond roughly $22,000 to $24,000 under the stated operations assumption. The choice flips to Bifrost when its retry semantics, Go deployment, or OTel-first model fits the team better.

Choose Portkey for a mid-market or enterprise buyer that needs managed identity, guardrails, budgets, retention, private deployment options, and support. The choice flips to Kong when Kong is already the company's API platform and consolidating control is worth its per-model meter.

Choose Helicone when request investigation, session debugging, and spend attribution are the daily work. Choose Braintrust Gateway when the same traces must feed evaluations and release checks. Braintrust's beta status means the direct bypass and an internal price ceiling are mandatory.

Choose OpenRouter while a small technical team is still comparing many models or needs provider-marketplace breadth. Keep a direct provider route. Once the app standardizes a small set of approved models, compare the 5.5% credit fee with Vercel's zero token markup, Requesty's 5%, or funded self-hosting.

The explicit flip condition is simple: change gateways when the cost or control you are missing becomes larger than the migration and operating burden of the next option. Do not migrate because a competitor has a longer feature list. Migrate because the current gateway cannot meet a measured latency budget, deployment boundary, audit requirement, fee ceiling, or exit target.

The ones to avoid as your only production route

Avoid any gateway as the sole route when its commercial or operating boundary is still moving. Three named choices need that caution for different reasons.

Avoid OpenRouter as the only production route during the reported ownership transition. Its catalog and routing remain excellent, and there is no basis for claiming its terms will worsen. The problem is concentration: model access, provider policy, credits, and fallback behavior all sit behind the same account. Keep one direct provider key and a tested adapter outside it.

Avoid Braintrust Gateway as the only route while it remains beta. Braintrust says the hosted gateway is designed for production, tracks uptime publicly, and is free during beta. It also says pricing will be announced before general availability. Treat $0 as a pilot price, define what price would trigger a move, and keep the bypass warm.

Avoid Kong AI Gateway as a greenfield default when the company does not already operate Kong. Four proxied models on one Serverless Plus control plane start at $425 per month before inference, and the buyer also inherits Kong's control-plane and API-program concepts. That can be excellent consolidation for an existing Kong customer and needless platform weight for a new app.

Also avoid a home-built passthrough after more than one application depends on it. A base URL proxy is easy. Correct streaming, error normalization, provider-specific parameters, fallbacks, budgets, key isolation, logs, and model deprecation handling form a maintained product. Build only when the unique policy is worth permanent ownership.

Your Monday move: prove the gateway is reversible

Do not start next week with a company-wide migration. Start with one production-shaped route and prove the 10-minute exit. The result should be a measured operating decision, not a cleaner architecture diagram.

1. 1

   Inventory one route

   Pick one customer-facing workflow and record its current provider, model, authentication method, monthly spend, p95 latency target, structured-output or tool requirements, and data policy. Choose a route representative enough to expose the hard parts but small enough to roll back.

2. 2

   Put the gateway behind an internal client

   Move only the gateway adapter into the request path. Keep provider-specific headers, model aliases, and fallback policy out of business logic. Store the prior direct configuration beside the gateway configuration.

3. 3

   Set one primary and one compatible fallback

   Do not begin with a routing tree. Pick a fallback that supports the same response protocol, structured output, tools, and data boundary. Put a total latency ceiling above the retry chain.

4. 4

   Force the failure

   Disable or misroute the primary in a controlled window. Confirm which attempts were made, which were billed, which provider answered, how long the chain took, and whether the application received the expected schema.

5. 5

   Run the 10-minute exit

   Bypass the gateway through configuration and a controlled deploy. If the service cannot return to its direct provider route within 10 minutes, log the dependency that blocked it and fix that dependency before expanding the rollout.

6. 6

   Buy the control that changed a decision

   Adopt the gateway only if it rescued requests, enforced a policy, exposed spend ownership, met a deployment boundary, or reduced a measurable operating cost. A dashboard no owner reviews is not a production outcome.

For most small product teams, Monday's pilot should use Vercel AI Gateway with no paid add-ons until a requirement earns them. For a platform team with a hard private boundary, use LiteLLM and assign the owner before the proxy receives traffic. For an enterprise governance project, start procurement and technical validation together, because retention, identity, deployment, support, and exit terms all affect the architecture.

The reported acquisition is the trigger, not the decision. The decision is whether your next model, provider, or gateway change can be handled as a controlled configuration update instead of a rewrite and emergency budget request.

Frequently asked questions

Which LLM gateway is the best?

LiteLLM is the best overall when a platform owner can run the gateway and the company values deployment control. Vercel AI Gateway is the best managed default. Portkey is stronger for managed enterprise governance, and OpenRouter is stronger while broad model discovery remains the main job.

Can you provide some examples of AI gateways?

Current examples include LiteLLM, Vercel AI Gateway, Portkey, Cloudflare AI Gateway, OpenRouter, Bifrost, Helicone, Braintrust Gateway, Requesty, and Kong AI Gateway. They span self-hosted proxies, managed gateways, model marketplaces, observability-led platforms, and enterprise API platforms.

What is the best open source AI gateway?

LiteLLM is the best open-source default because its $0 plan combines 100+ providers, virtual keys, budgets, rate limits, fallbacks, logs, and Prometheus. Bifrost is the better alternative when explicit nested retry behavior, a Go binary, or its OpenTelemetry implementation is the deciding requirement.

Which AI gateway is best for a startup versus an enterprise?

A startup should usually start with Vercel, Cloudflare, or Requesty to avoid creating an internal platform job. An enterprise should choose by governance and deployment boundary: Portkey for managed controls, LiteLLM or Bifrost for owned infrastructure, and Kong when the organization already standardizes API traffic there.