Best AI Gateways for Coding Agents

Vercel AI Gateway is the best AI gateway for most coding-agent teams because one command now configures 29 agents, per-user budgets can cap a teammate across their attributed keys, and its base token layer adds no markup. On a $2,000 monthly model bill, the gateway fee is $0 with Vercel, $100 with Requesty, and $110 with OpenRouter Standard before optional controls, so the decision now belongs in the engineering budget, not the experimentation drawer.

The short answer: which AI gateway should you choose?

Choose Vercel AI Gateway unless your deployment, attribution, or governance requirements point somewhere specific. It has the cleanest current path from separate Claude Code, Codex, Cursor, and OpenCode configurations to one model bill, one set of fallbacks, scoped spend controls, and one spend view.

The decision flips away from Vercel in five clear cases. Pick Requesty when the finance question is which repository, branch, or developer created the spend. Pick LiteLLM when the gateway process and provider-key storage must run in infrastructure you operate. Pick OpenRouter when access to a broad model and provider catalog matters more than harness-specific setup. Pick Portkey when managed guardrails, circuit breakers, and policy are the funded requirement. Pick Cloudflare AI Gateway when Workers, Cloudflare logging, and Cloudflare security already form the control plane.

An AI gateway is the control layer between a coding agent and model providers. The coding agent still plans, edits files, runs commands, and calls tools. The gateway decides where model requests go, what they may cost, which provider receives them, what happens after a timeout, and what gets logged.

That distinction matters. A gateway will not make a weak coding model better, repair a poor repository instruction file, or review unsafe code. It can prevent a provider outage from ending a long run, cap a runaway key or teammate, and show that a migration branch consumed four times the model budget of a routine bug fix. Buy it for control, not intelligence.

Why coding agents make the gateway a budget line

Coding agents turn a small routing decision into an operating-cost decision because one task can create a chain of model calls. A chat answer may need one response. A coding agent can inspect a repository, search symbols, propose a patch, run tests, read failures, revise the patch, and ask a stronger model to review the result.

Vercel's production index for April 2026 found that 22.2% of requests carried 58.9% of tokens, making tool-using requests about 2.6 times the overall per-request token average. The same dataset reported that fallbacks rescued 3.5% of requests. If a 10,000-request workload matched that aggregate, roughly 350 requests would complete through a fallback rather than fail at the first provider. That is an illustration, not a promised rescue rate for another workload, but it shows why reliability belongs beside model price.

The base gateway fee is easier to compare when the upstream model bill stays fixed. At $2,000 per month in provider-priced inference:

• Vercel adds $0 in token markup.
• Requesty's 5% markup adds $100.
• OpenRouter Standard's 5.5% credit-purchase fee adds $110.
• Cloudflare Unified Billing adds $100 when credits are purchased through it.
• Portkey starts at $49 per month for 100,000 recorded logs, a different meter from token spend.
• LiteLLM's open-source license adds $0, while hosting and operator time remain your responsibility.

The percentage difference is not the whole decision. Requesty's extra $100 can be cheap if branch-level attribution stops one uncontrolled repository from consuming far more. Portkey's $49 can be cheap if a circuit breaker preserves a release workflow. LiteLLM's zero license fee can be expensive if a platform engineer becomes the permanent on-call owner for the proxy.

The gateway should reduce the cost of changing models, providers, and harnesses. If it only replaces six provider invoices with a seventh invoice, it has not earned its place.

How these gateways were picked

The six picks were judged on the work coding agents create, not on a generic API feature checklist. Prices and product pages were re-verified on 22 October 2026. The ranking is based on current documentation, normalized cost analysis, and the consequences of each product boundary; it does not claim production testing of these tools.

Six criteria decide the order:

1. Coding-harness setup: A gateway that documents Claude Code, Codex, Cursor, and related agents has less integration risk than one that only promises an OpenAI-compatible endpoint.
2. Routing reliability: Provider ordering, timeouts, retries, model fallbacks, and circuit breakers matter because an agent can lose a long chain at the last model call.
3. Cost visibility: Model spend should be attributable to a key, agent, repository, developer, team, or policy rather than appearing as one undifferentiated token total.
4. Policy control: Provider allowlists, approved-model lists, budgets, data-retention controls, and audit logs decide whether a team can move beyond individual experimentation.
5. Deployment burden: Managed gateways charge money to remove operations. Self-hosted gateways remove platform fees by returning availability, upgrades, storage, and incident response to the buyer.
6. Current price: Every tier and limit comes from the live vendor page. Model inference prices are excluded from the ranking because they change by model and provider, and because this comparison holds the upstream bill constant.

Helicone was considered but not ranked. It is an observability product with gateway features, but its clearest advantage is tracing and analysis rather than broad coding-harness configuration. In its March 3, 2026 acquisition announcement, Helicone said its “services will remain live for the foreseeable future in maintenance mode”; its current site now says it is no longer part of Mintlify, with details still to come. Generic API gateways were also cut. They can proxy HTTP traffic, but coding agents need model-aware fallbacks, token budgets, prompt and response controls, and compatibility with several wire protocols.

The result is a shorter list with a harder decision rule. Each product below has a job it wins and a wall where another product becomes the better purchase.

1. Vercel AI Gateway: best overall for coding agents

Vercel AI Gateway is the best default because it removes the setup work that used to keep gateways out of individual coding-agent workflows. Its current CLI can provision a key, preview the configuration changes, and configure 29 supported agents with npx vercel@latest ai-gateway setup.

The live support table now lists 29 agents, including Claude Code, Cline, OpenAI Codex, Cursor, Hermes, Kilo Code, omp, OpenClaw, OpenCode, and Pi. Vercel also documents manual paths for additional tools. Claude Code, Codex, and Cursor receive dedicated compatibility endpoints because their wire behavior needs more than the generic OpenAI surface. That is the feature that changes the buying decision: the gateway is no longer only infrastructure behind an application you built. It can sit behind the coding tools your engineers already use.

For a 12-person product team, the practical outcome is one team budget, separate per-user caps, and one fallback policy across different working styles. One engineer can stay in Claude Code, another can run Codex from the terminal, and a third can use Cursor. Their requests can still land in one spend view without forcing the company to choose one editor or one model lab.

Since August 31, 2026, Vercel's per-user budgets can cap one member's combined spend across every API key attributed to that user, alongside team, project, and key budgets. New keys default to user attribution; exhausting one person's allowance makes new requests on that member's keys return HTTP 402 without stopping team-attributed traffic, provided the shared key and team still have budget. The current budget documentation confirms that the crossing request can still finish and BYOK provider spend remains outside every AI Gateway budget, so this stops subsequent gateway-funded calls rather than enforcing a perfectly hard ceiling.

Best for: Teams using several coding agents that want the fastest managed setup
Standout: One CLI workflow for 29 supported agents, plus per-user budgets and dedicated Claude Code, Codex, and Cursor endpoints
Pricing: $5 monthly free credit; paid inference at provider list rates with zero token markup
Free trial: Ongoing free tier on eligible models, not a time-limited trial

Pricing is unusually clean at the base layer. Vercel's live pricing page says there is no markup and no platform fee on tokens; payment processing fees may still apply. The free tier includes $5 in monthly credit, a subset of eligible models, and lower per-model limits. Buying credits moves the account to Pay as you go and ends the monthly free credit. Bring Your Own Key is available only after moving to the paid tier, and Vercel adds no BYOK fee.

There are two catches. First, zero markup applies to the token layer, not every control. On Pro and Enterprise, team-wide provider allowlisting costs $0.10 per 1,000 successful requests and team-wide zero data retention costs $0.10 per 1,000 requests. Trace drains cost $0.05 per 1,000 traces plus $0.50 per GB of egress. Custom reporting has its own write and query meters. A small team can ignore most of these; a regulated team should price them before declaring the gateway free.

Second, a failed BYOK request may retry with Vercel system credentials and charge the fallback usage against the gateway credit balance. That is a sensible reliability default and a budgeting edge case. If finance expects every request to remain on an existing provider contract, the fallback path must be reviewed rather than assumed.

The routing controls are strong enough for most product teams. Vercel documents provider filtering, ordering, sorting, automatic caching, provider timeouts, and model fallbacks. You can send normal code-completion traffic to a preferred provider, trigger a fast failover when latency exceeds tolerance, and keep a more expensive model as the final recovery path.

The main wall is deployment ownership. Vercel AI Gateway is managed. It is not the choice for a team that requires the gateway process, database, keys, and logs to run inside its own network. LiteLLM wins that requirement before feature comparisons begin.

Set up Vercel AI Gateway without turning the migration into a project

The safest setup preserves a direct-provider rollback and starts with one repository. Do not change every developer and every agent at once.

1. 1

   Create a bounded pilot key

   Create a separate member-attributed gateway key for each pilot developer, give every key a weekly or monthly spend budget, and set a default user budget to cap that member's combined keys. Keep customer-facing and other shared workload keys attributed to the team so one person's allowance cannot stop production.

2. 2

   Run the documented setup command

   Run npx vercel@latest ai-gateway setup. Let the CLI detect installed agents, choose only the pilot tools, and review the displayed diff before accepting any configuration write.

3. 3

   Keep one primary model and one fallback

   Start with the model the team already trusts. Add one provider or model fallback with comparable tool-use behavior. On Vercel, use a virtual model to attach that routing policy when the agent cannot send gateway options itself. A large routing tree makes a failed run harder to explain.

4. 4

   Verify identity and spend labels

   Run one contained task from each configured agent. Confirm that the dashboard identifies the agent, model, provider, token usage, cost, latency, and fallback status the way the buyer expects.

5. 5

   Preserve the direct route

   Keep the previous provider configuration in a documented rollback file. If the gateway changes tool calling, model discovery, or latency, the pilot should be reversible in minutes.

2. Requesty: best for branch, repository, and developer cost attribution

Requesty is the best gateway when the engineering manager needs to connect model spend to the work that caused it. Its Claude Code integration can tag requests by branch, repository, developer, and agent version, which turns a token bill into something a team can investigate.

That attribution is more useful than a low fee for teams running parallel migrations, feature branches, and automated reviews. A B2B SaaS team could discover that background review is cheap while one repository's test-fix loop consumes most of the monthly spend. The response is then specific: adjust the policy for that repository or model, not cut every developer's access.

Best for: Teams that need coding-agent cost by branch, repository, or developer
Standout: Claude Code analytics tags plus routing policies, EU data residency, and an MCP gateway
Pricing: $0 on free models; Pay as you go adds 5% to base model costs; Enterprise is custom
Free trial: Free tier with 200 requests per day and no credit card

Requesty's current pricing page lists 600+ models across 20+ providers. Pay as you go has no subscription, seat fee, minimum spend, or separate charge for routing, caching, fallbacks, and EU data residency. At $2,000 in monthly provider-priced inference, the 5% markup is $100.

That $100 is easy to defend if the metadata prevents a larger uncontrolled run or makes chargeback possible. It is harder to defend for a solo developer who only wants a different base URL. OpenRouter offers a broad provider catalog, and Vercel offers the cleaner zero-markup route for supported coding agents.

Requesty's Enterprise tier adds SSO, RBAC, audit logs, approved-model policies, PII detection, group budgets, service accounts for CI/CD, and custom SLAs. Those features make it credible for a larger engineering organization, but the price is custom. A team cannot compare Enterprise without a quote and a representative request profile.

Both the commercial pricing page and the Claude Code integration page now say 600+ models. That agreement removes the former documentation mismatch, but a buyer should still verify the exact models needed in the account library rather than treating the headline count as a guarantee.

The Claude Code setup is narrower than Vercel's multi-agent CLI but deeper in attribution. Requesty's CLI can write the Claude configuration and back up the existing file. An optional shell wrapper injects repository, branch, user, and agent-version headers at session start. The wrapper is visible in the shell configuration and the headers are stripped before forwarding to the model provider.

The wall is the percentage meter. A 5% markup scales with model spend even when the gateway's control-plane work does not. At $20,000 per month, it becomes $1,000. A larger buyer should compare that bill with Portkey's subscription model, LiteLLM's operating cost, and a custom Requesty Enterprise quote.

3. LiteLLM: best self-hosted gateway

LiteLLM is the best choice when control of deployment and data outranks convenience. Its open-source proxy is free to self-host for production and places 100+ providers behind one OpenAI-compatible API.

For a mid-market CTO with a private network boundary, the appeal is direct: the company operates the proxy, provider-key storage, virtual keys, budgets, logs, and Prometheus metrics. Model requests still go to the selected providers, but the architecture removes a separately hosted gateway from that path. Deployment ownership also includes release verification and incident response.

October 21, 2026: LiteLLM reports that credential-stealing 1.107.0 artifacts reached PyPI and Docker that day; the affected packages and images were removed or repointed to clean builds. Its affected window is unpinned pip installs from 11:39 to 13:23 UTC, or Docker v1.107.0, latest, main-latest, and main-stable from 11:46 to 14:20 UTC. Treat any environment that executed an affected artifact as compromised, including a cached copy used later. Follow its cleanup before running pip again: remove the malicious startup files, stop the detached daemon, and preferably rebuild the environment clean, pinned to litellm==1.106.2. Pin verified clean container images by digest. Rotate every provider key in the proxy database, master and virtual keys, the database password, reachable IAM credentials, and secrets in any process environment on the host, including repository credentials present there. LiteLLM says its private enterprise registry was unaffected.

Best for: Platform teams that require self-hosted or air-gapped model access
Standout: Free open-source proxy with 100+ providers, virtual keys, budgets, fallbacks, and Prometheus
Pricing: $0 open source; Enterprise is annual and custom-priced by capacity and deployment
Free trial: 30-day Enterprise trial; open source remains free

The software price is the easiest number in the roundup and the most likely to be misunderstood. The open-source gateway costs $0, including production use. It includes users and teams, spend tracking, rate limits, request and response logging, and LLM fallbacks. There is no per-token LiteLLM license fee.

The operating price is not $0. Someone must deploy the proxy, manage its database and secrets, scale it, monitor it, upgrade it when providers change APIs, preserve logs, test fallbacks, and respond when the gateway becomes the shared point of failure. LiteLLM turns a vendor bill into an infrastructure responsibility. That can be a good exchange for a platform team and a poor exchange for a five-person startup.

Enterprise adds SSO, SCIM, OIDC or JWT authentication, audit logs, secret-manager integrations, key rotation, organization controls, a multi-region control plane, support, SLAs, and air-gapped deployment. Pricing is annual and depends on request capacity, deployment architecture, and support rather than tokens. That boundary matters: a regulated company may begin with open source and still need Enterprise as soon as identity, audits, or round-the-clock support become mandatory.

LiteLLM also has two product surfaces that buyers often blur together. The Python SDK is an application library. The Proxy Server is the centralized gateway with authentication, multi-tenant spend, virtual keys, and an admin dashboard. A coding-agent rollout that needs shared policy should evaluate the proxy, not merely add the SDK to a few scripts.

The coding-harness wall is documentation and ownership. LiteLLM now documents a lite CLI for Claude Code and Codex, but the broader rollout still needs a platform owner. Each agent's environment variables, response format, model discovery, and tool-use behavior still need validation. Codex's Responses API behavior and Claude Code's Anthropic protocol deserve separate pilot checks.

4. OpenRouter: best for model breadth and fast experiments

OpenRouter is the best gateway for comparing a large model market through one account. Its live Standard plan lists 500+ models from 80+ providers, a broad catalog for comparing model and hosting choices.

That breadth is valuable to a solo technical builder or a small research-heavy team. A coding agent can compare a frontier model for repository planning, a faster model for search and classification, and an open model for routine transformations without opening a billing account with every provider.

Best for: Rapid model comparison and access to a broad provider market
Standout: 500+ models, 80+ providers, and a task-aware Auto Router
Pricing: $0 Free; Standard adds 5.5% to credit purchases, Business 8%; Enterprise discounts are custom
Free trial: Free tier with 25+ models, 4 providers, and 50 requests per day before qualifying credit purchases

The commercial tradeoff is explicit. OpenRouter's Standard plan has no minimum spend and charges 5.5% when you buy credits, not on individual inference requests. At $2,000 of purchased credits, that is $110. Business charges 8% on credit purchases. Standard and Business include $25,000 in list-price BYOK inference each month before a 5% fee applies; Enterprise allowances and fee discounts are custom.

The free plan is useful for confirming compatibility and weak for sustained agent work. Fifty requests per day can disappear inside a long coding loop. The free-model allowance rises to 1,000 daily requests once the account has bought at least $10 in credits; the 20-requests-per-minute cap still applies. Treat it as a connection check, not a team budget.

OpenRouter's Auto Router is more interesting than the raw catalog count. The current routing documentation says it classifies prompts into roughly 30 task types, including code debugging and multi-step agent planning, then ranks models using aggregate spend over a trailing seven-day window. It considers capabilities, tool support, cost, account restrictions, and fallback options.

That market signal makes experimentation easy and reproducibility harder. The router may choose a different model on each turn. Session stickiness prefers the prior model when it remains a top candidate, but a task shift can still change the selection. For a coding agent that creates a patch over many turns, a mid-session model change may affect tool syntax, reasoning style, or output discipline.

The fix is not to avoid routing. It is to decide where dynamic routing belongs. Use it for evaluation, low-risk classification, or a bounded background step. Pin an approved model and provider policy for a release-critical patch unless the team has tested cross-model continuity.

OpenRouter also exposes policy-based routing and fallbacks across providers. That is useful when the same model is sold by several inference hosts. It is less useful when the buyer needs repository-level chargeback, self-hosted control, or managed enterprise guardrails. Requesty, LiteLLM, and Portkey are stronger in those separate jobs.

5. Portkey: best managed governance layer

Portkey is the best pick when the funded requirement is a managed control plane, not merely a unified endpoint. Its gateway combines fallbacks, conditional routing, retries, a circuit breaker, load balancing, canary tests, MCP support, budgets, rate limits, caches, and guardrails.

That set fits a mid-market platform team moving from individual agent keys to approved access. One policy can limit models, one budget can cap a team, and one circuit breaker can stop repeated calls to a failing provider. The product is built for the moment when “give developers a gateway key” becomes an identity, policy, and incident-management problem.

Best for: Managed routing, guardrails, and governance for a growing platform team
Standout: Circuit breakers, canary testing, MCP controls, conditional routing, and an open-source local gateway
Pricing: $0 Developer, $49/month Production, custom Enterprise
Free trial: Developer plan is free forever but explicitly not suitable for production

The plan boundaries are unusually candid. Portkey's Developer plan records 10,000 logs per month, keeps logs for three days, and keeps metrics for 30 days. The page explicitly says it is not suitable for production.

Production costs $49 per month and records 100,000 logs, with $9 charged for each additional 100,000 requests up to 3 million. It keeps logs for 30 days and metrics for 90 days. At 200,000 requests, the subscription is $58 before upstream inference. The same page says Production is not recommended when custom security controls or data-residency guarantees are required.

Enterprise is the necessary tier for those requirements. It is custom-priced and adds 10 million-plus recorded logs, custom retention, SSO, granular budgets and rate limits, private-cloud and VPC hosting, data-lake export, and advanced compliance. That is a meaningful jump from a $49 card to a procurement process.

Portkey also publishes an open-source local gateway that runs with npx @portkey-ai/gateway. It provides a way to test the routing surface or self-host the data path. A buyer should still distinguish the local gateway from the managed observability, policy, support, and Enterprise controls that make Portkey the ranked choice here.

The current product transition deserves attention. Portkey's docs now say it is Prisma AIRS AI Gateway. The gateway pages and prices remain live, but a buyer should ask which product name appears on the contract, which roadmap applies, and how standalone Portkey accounts map to the Palo Alto Networks portfolio. That is procurement diligence, not a reason to reject the tool.

The coding-agent wall is setup. Portkey can sit behind compatible agent protocols and brings a deeper general control plane than Vercel. Its documented gateway setup leaves the buyer to validate each agent configuration. Choose it when policy is worth the integration work, not because its feature list is longer.

6. Cloudflare AI Gateway: best for teams already on Workers

Cloudflare AI Gateway is the best low-friction choice when Cloudflare already handles the application's edge, logs, and security. Its core gateway features are currently free on every plan, including analytics, caching, and rate limiting.

The product is compelling for a team whose agent or internal developer platform already runs on Workers. The same account can call third-party and Cloudflare-hosted models through an OpenAI-compatible REST surface, record costs and errors, cache safe repeat requests, apply rate limits, scan for sensitive data, and retry failed calls.

Best for: Teams already using Workers, Cloudflare logging, or Cloudflare security controls
Standout: Free core gateway, edge integration, DLP, caching, and OpenAI-compatible third-party model access
Pricing: Core features $0; Unified Billing credit purchases add 5%; guardrails use Workers AI pricing
Free trial: Core gateway features are free rather than time-limited

The pricing page now separates logging by account history. Accounts that created their first gateway before September 24, 2026 use Legacy Logs: Workers Free stores 100,000 logs total across all gateways, and Workers Paid stores 10 million per gateway. Accounts whose first gateway was created on or after that date use Workers Logs: Free includes 200,000 log events per day with three-day retention; Paid includes 20 million per month, then $0.60 per additional million, with seven-day retention. Core analytics, caching, and rate limiting remain free.

Unified Billing adds a 5% fee when credits are purchased through Cloudflare. A $2,000 credit purchase therefore costs $2,100, while provider inference is still passed through without markup. The distinction matters: the model price is unchanged, but consolidating credentials and billing has a fee.

Data Loss Prevention scanning is free on all plans. Accounts without a Zero Trust subscription receive two predefined DLP profiles, while broader profiles depend on the Cloudflare One subscription. Guardrails are not part of the free core: Cloudflare bills their prompt and response evaluation as Workers AI token inference.

Cloudflare also exposes useful request controls. Its REST documentation supports per-request timeouts, retry methods, up to five attempts, and up to 60,000 milliseconds of retry delay. The request-handling guide says timeouts measure arrival of the first response data and the final retry waits for completion, so these settings do not establish a hard deadline for the whole agent loop.

The wall is coding-harness ergonomics. Cloudflare's REST documentation describes application endpoints; a coding-agent rollout still needs a compatibility pilot. A builder must confirm how each harness changes its base URL, authentication, model discovery, and protocol. The software line may be $0 while the integration line lands on the engineering team.

Who should pick what?

The best gateway is the one that removes the team's current coordination cost without creating a larger operating burden. Start with the constraint that cannot be negotiated, then compare fees.

Choose Vercel AI Gateway for a mixed group using Claude Code, Codex, Cursor, OpenCode, and related agents. The choice flips when self-hosting is mandatory or when cost must be tied to repository and branch rather than only the member, key, agent, and model.

Choose Requesty for an agency, consultancy, or product organization that needs branch, repository, and developer attribution. The choice flips when that metadata will not change a budget decision, because the 5% markup then buys information no one uses.

Choose LiteLLM for a platform team with an established container, database, secret, logging, and on-call practice. The choice flips to a managed gateway when the proxy would be owned informally by a product engineer.

Choose OpenRouter while a solo builder or research team is still comparing models and providers. The choice flips after the shortlist stabilizes and the recurring 5.5% fee becomes larger than the value of broad catalog access.

Choose Portkey when approved models, guardrails, circuit breakers, canary tests, and managed governance form the purchase case. The choice flips when the organization only needs one endpoint and a spend dashboard.

Choose Cloudflare AI Gateway when Workers and Cloudflare security are already paid for and understood. The choice flips when adopting the surrounding platform would create more integration work than the gateway removes.

There is one more rule: keep the gateway separate from the harness decision. Claude Code, Codex, and Cursor solve different engineering jobs, while the gateway controls their model traffic. A company can standardize the gateway without standardizing the editor. That is often the more useful control boundary.

For a broader agent shortlist, compare the best AI coding agents. For SSO, retention, audit, and rollout questions beyond the gateway, use the enterprise coding-agent comparison.

The ones to avoid for this job

Avoid Helicone as the primary purchase when the immediate problem is coding-harness setup. Helicone's pricing page lists Hobby free for 10,000 requests per month, Pro at $79 per month, and Team at $799 per month, with usage charges on paid plans. Its March 3, 2026 announcement described “maintenance mode” with continuing security and model updates and bug and performance fixes; today's site says it is no longer part of Mintlify, so confirm the current roadmap before a new rollout. Its observability, sessions, prompts, and analysis can be valuable. The ranking changes only when visibility is the main problem. It does not beat Vercel's current setup path, Requesty's repository attribution, or LiteLLM's deployment control for this query.

Avoid a generic API gateway chosen only because the company already owns it. Traditional gateways understand routes, authentication, and HTTP policy. Coding-agent traffic adds provider-specific models, token accounting, tool-use compatibility, prompt caching, model fallbacks, and several response protocols. Extending a general gateway can make sense for a platform team, but “we already have Kong” is not an implementation plan.

Avoid a home-built passthrough proxy once multiple agents depend on it. Changing a base URL is easy. Maintaining provider adapters, safe retries, streaming responses, budget counters, key isolation, log retention, and model deprecations is a product. Build it only when a unique policy or deployment constraint justifies permanent ownership.

Avoid dynamic model routing for every step of a release-critical agent loop until cross-model continuity has been evaluated. A router can choose an efficient model for each task and still make a long patch harder to reproduce. Pin the model for the change-producing steps, then use dynamic routing for bounded support work.

Finally, avoid routing every developer on day one. A gateway can change authentication, model discovery, caching, error behavior, and fallback selection while leaving the coding-agent interface looking unchanged. That is why a bounded pilot and a direct-provider rollback belong in the rollout.

Frequently asked questions

Which LLM gateway is the best?

Vercel AI Gateway is the best default for coding agents because it combines one-command setup for 29 supported agents, per-user budgets across attributed keys, and zero token markup. LiteLLM is better when self-hosting is mandatory, Requesty when repository and branch attribution matters most, and Portkey when managed governance is the purchase case.

What are OpenRouter's pricing and fees in 2026?

OpenRouter's Standard plan charges 5.5% on credit purchases; Business charges 8%. Both offer 500+ models and 80+ providers with no minimum spend. Free access lists 25+ free models, 4 providers, and 50 requests per day; buying at least $10 in credits raises the free-model daily allowance to 1,000, with 20 requests per minute. Standard and Business BYOK include $25,000 of list-price inference per month before a 5% fee; Enterprise allowances are custom.

How much does Cloudflare AI Gateway cost in 2026?

Cloudflare's core AI Gateway features are free and Unified Billing credit purchases add 5%. Legacy Logs retain the 100,000-total Free and 10-million-per-gateway Paid storage limits. Accounts whose first gateway was created on or after September 24, 2026 use Workers Logs: 200,000 events/day and three-day retention on Free; 20 million/month plus $0.60 per additional million and seven-day retention on Paid. Guardrails are billed separately as Workers AI inference.

Can one gateway route both Claude Code and Codex?

Yes. The gateway must support the protocols each harness expects or provide dedicated compatibility endpoints. Vercel documents separate Claude Code and Codex endpoints, while self-hosted and general gateways require the buyer to validate each harness configuration.

Your Monday move

Do not spend Monday migrating the whole company. Spend it proving that one gateway can reduce cost ambiguity and provider risk for one representative repository.

Monday: define the control boundary

Pick one repository, one small developer group, and the two coding agents they already use. Write the funded reason in one sentence: consolidate billing, rescue provider failures, attribute spend, enforce approved models, or keep traffic in a private deployment. If the sentence names three unrelated goals, narrow the pilot.

Create a dedicated gateway key with a spend cap. On Vercel, use a member-attributed key for each pilot developer, set the default user budget, and keep shared production keys team-attributed. Select one primary model and one fallback with comparable tool-use support. Preserve the direct provider configuration in a rollback file, and record the current provider bill before any traffic moves.

Tuesday: connect, then inspect the diff

For Vercel, run the documented setup command and review every change before it writes. For Requesty, back up the Claude Code settings and enable only the attribution headers the team will use. For LiteLLM, deploy the proxy through the normal infrastructure path rather than a laptop. For every gateway, confirm that secrets land in the approved store.

Run one bounded issue from each agent. Check model selection, tool calls, streaming, errors, cache behavior, cost, and the identity attached to the request. A successful response is not enough if the dashboard cannot explain who spent the money or which fallback answered.

Wednesday and Thursday: force the failure path

Trigger a controlled timeout or use a test route that sends the primary to an unavailable provider. Confirm that the fallback preserves the wire format the coding agent expects. Check whether the failed attempt is billed, whether the fallback uses a different credential, and whether the trace identifies both attempts.

Give the pilot one routine bug, one multi-file change, one test-repair loop, and one review task. Record completed task cost, provider failures, rescued requests, time spent changing configuration, and developer-reported friction. Do not compare prompt counts without the work outcome.

Friday: buy the control that changed a decision

Adopt the gateway only if its information or reliability changes an operating decision. A rescued request matters. A repository budget overrun matters. A provider-policy violation matters. A dashboard full of token charts that no owner reviews does not.

For most mixed-agent teams, the Monday choice is Vercel AI Gateway with member-attributed pilot keys, one default user budget, one primary model, one fallback, and no paid add-ons until a policy requires them. The choice becomes Requesty when cost ownership must reach the repository and branch. It becomes LiteLLM when the gateway and its key storage must run inside the company's infrastructure.

Keep the gateway configuration versioned, the rollback path documented, and the model policy small. The point is not to route through more vendors. It is to make the next provider outage, model release, and budget review a configuration change instead of a company-wide migration.