Enterprise LLM Gateway for Cost Tracking Across All Coding Agents in 2026

A FinOps lead at a 2,000-engineer enterprise opens her chargeback model in May 2026. Anthropic: $812K. OpenAI: $487K. GitHub Copilot Enterprise: $144K. Azure OpenAI on the data team: $221K. That’s $1.66M for the month, attributable in aggregate to “AI coding tools” and to nothing more granular. Engineering Director runs Claude Code in his terminal, Cursor in his IDE, Codex CLI on the data team, Copilot in Visual Studio, and Cline on power-user workstations, five tools, five billing relationships, five dashboards, none in the same vocabulary.

The story falls apart when finance asks “what did the payments team spend on AI coding in April?” Anthropic groups by API key. OpenAI by project. Copilot reports seats but not dollars per repo. Cursor shows premium-request counts. A column-by-column join is impossible, each agent counts a different unit at different prices, and Cline routes through whichever provider the user configured and shows nothing centrally.

An enterprise LLM gateway in front of every coding agent fixes this. It’s the only artifact that sees every prompt from every agent and can attach uniform dimensions (developer, repo, BU, cost center) before the call leaves the network. The dashboard becomes the chargeback table. The invoices become the reconciliation check.

The five gateways below all do cross-agent cost tracking. Only one turns the same trace into a feedback loop that reduces tokens per dollar across every agent simultaneously. This is the 2026 cohort, scored on seven axes when the workload is “all coding agents, one chargeback table.” Sibling posts say “AI gateway”; this post uses “LLM gateway” because that’s what FinOps committees write in the SOW.

TL;DR: pick by who owns the chargeback table

Why cross-agent cost tracking is the 2026 problem

Single-agent cost tracking was a 2025 problem. By 2026 no coding agent has more than 45% share inside a 2,000-engineer org. Average shape: 30% Claude Code, 25% Cursor, 15-20% Codex CLI on data teams, 15% Copilot from a 2024 rollout, the remainder Cline, Aider, and the unsanctioned long tail. Finance treats this as one problem; engineering treats it as five; the gateway collapses five into one.

Three mismatches make it hard.

Unit mismatch. Anthropic prices claude-opus-4-7, claude-sonnet-4-6, and claude-haiku-4-5 at three different rates. OpenAI prices gpt-5.5 differently, with separate rates for cached input tokens that didn’t exist in 2025 pricing. Copilot Enterprise prices per seat with overage on premium requests. Cursor prices premium-model requests at fixed unit prices. The chargeback table needs a unified cost model converting every agent’s native pricing into the same dollar column.

Identity mismatch. Claude Code authenticates with a shared Anthropic key. Cursor uses one Cursor team account fanning to a single OpenAI project. Codex CLI uses OpenAI keys that may or may not be SSO-mapped. Copilot Enterprise authenticates through GitHub SAML. The gateway is the only point that resolves all four identity systems to the same SSO claim and stamps a single developer_id on every call.

Attribution mismatch. Anthropic rolls up by API key. OpenAI by project. Copilot by seat. Cursor by team. None roll up by repo, cost center, feature branch, or BU. The gateway is the only artifact that attaches repo and BU metadata at request time.

A gateway sits between every client and every provider, normalizes cost into a uniform dollar column, attaches identity and metadata, and forwards. The result is one chargeback table covering every agent, developer, repo, and BU. All five picks below support pointing CLI and IDE agents at them via ANTHROPIC_BASE_URL, OPENAI_BASE_URL, or equivalent.

The 7 axes we score on

The default “best gateway” axes are too generic for a FinOps brief. Each pick is scored on seven axes that specifically affect cross-agent chargeback.

Verdict line at the end of each pick scores all seven.

How we picked the cohort

We started from public enterprise LLM gateways advertising at least three of the four major coding-agent endpoints (Anthropic, OpenAI, Azure OpenAI, GitHub Copilot BYOM) as of May 2026. We removed gateways that can’t apply per-call metadata across multiple agents simultaneously and those without a chargeback export path FinOps can ingest. Five remain.

1. Future AGI Agent Command Center: Best for closing the loop across every coding agent

Verdict: Future AGI is the only gateway here that takes cross-agent traces and uses them to reduce cost per developer per agent over time. The other four are observation layers; Agent Command Center is wired to a per-agent self-improving optimizer.

What it does:

• Cross-agent normalization through traceAI (Apache 2.0) speaking Anthropic, OpenAI, Azure OpenAI, Bedrock, and Copilot BYOM with one span schema. Every call normalizes into agent_id, provider, model, token counts, cached-token counts, and dollar_cost against current pricing.
• Per-agent + per-developer + per-repo dimensions as native span attributes: agent_id, fi.attributes.user.id (SSO-resolved), fi.attributes.repo, fi.attributes.business_unit. One-click filter for “who spent what on which agent against which repo.”
• IDE + CLI + terminal coverage in front of every provider endpoint. Claude Code, Cursor, Codex CLI, Copilot, Cline, GitHub Actions, CI all hit the same hop.
• Chargeback export through native Snowflake and BigQuery exports plus Apptio and CloudHealth connectors.
• Monthly invoice reconciliation through a built-in delta report against Anthropic, OpenAI, Azure, and GitHub invoices. 1-3% delta explained by caching, retries, rate-limit refunds, bulk discounts.
• Optimizer hooks per agent through fi.opt.optimizers configured per-agent. Claude Code routing adjusts independently from Codex CLI adjusts independently from Cursor’s premium budget. ProTeGi, Bayesian, GEPA rewrite per-agent prompts against per-agent eval datasets.
• Vendor breadth covering Anthropic, OpenAI, Azure OpenAI, Bedrock, Vertex, Cohere, Mistral, plus on-prem Ollama and vLLM.

Where it falls short:

• Normalization is strongest when each agent points at the gateway from day one. Late onboarding (a team on Cursor’s billing for six months) means the chargeback table covers only the post-onboarding window; backfill is lossy.
• agent-opt is opt-in, start with traceAI + ai-evaluation for one-week chargeback PoCs and turn the optimizer on once eval baselines stabilize. The optimizer gets stronger as production trace data accumulates, that’s the design, not a setup tax.
• Copilot Enterprise BYOM is newer than the Anthropic and OpenAI paths; expect two to three weeks to wire seat-mapping cleanly.

Pricing: Free 100K traces/month. Scale $99/month. Enterprise custom with SOC 2 Type II, HIPAA, GDPR, and CCPA all certified, BAA available, AWS Marketplace for EDP drawdown.

Score: 7/7 axes.

2. Portkey: Best for hosted FinOps catalog across multiple coding agents

Verdict: Portkey is the most polished hosted-only product in this category, with the deepest pre-built FinOps catalog. If you already operate Claude Code, Cursor, and Codex CLI and the FinOps lead wants the dashboard by Friday, Portkey is the fastest path. It observes, attributes, exports; it doesn’t optimize back.

What it does:

• Cross-agent normalization through Portkey’s virtual-key system: each agent gets a virtual-key class fanning out to underlying provider keys. Dashboard normalizes input, output, and cached tokens. Pre-built per-agent views for Claude Code, Cursor, Codex CLI, Copilot.
• Per-agent + per-developer + per-repo dimensions through metadata headers and the virtual-key hierarchy. Slice by class (agent), key (developer), and custom metadata (repo, BU).
• IDE + CLI + terminal coverage through *_BASE_URL configuration plus CI runners. Each agent’s wrapper must send the metadata headers, one-time setup per agent.
• Chargeback export through Snowflake, BigQuery, S3, Splunk. Apptio and CloudHealth via custom mapping.
• Monthly invoice reconciliation through scheduled reports. Delta categorization less granular than Future AGI’s but covers caching, retries, and rate-limit refunds.
• Optimizer hooks per agent limited to per-virtual-key budget caps and Slack alerts.
• Vendor breadth covers Anthropic, OpenAI, Azure OpenAI, Bedrock, Vertex, Cohere, Mistral, Together, Anyscale, and more.

Where it falls short:

• No self-improving cost optimization; intervention is human-driven.
• The April 30, 2026 Palo Alto Networks acquisition announcement is a procurement variable. Multi-year contracts need assignment-and-novation with a termination-without-penalty trigger if post-close DPA degrades.
• Metadata-header model requires per-agent wrapper config; without it, aggregation is per-developer only. Adding a chargeback dimension means updating every wrapper.

Pricing: Free 10K req/day. Pro $99/month. Enterprise custom with SOC 2 Type II attested, ISO 27001 on the list, mature DPA.

Score: 6/7 axes (missing: per-agent optimizer hooks).

3. Kong AI Gateway: Best when Kong is already the chargeback gateway for REST

Verdict: Kong AI Gateway is the pick when the platform team already runs Kong as the REST chargeback gateway and wants the AI cost layer to inherit the pattern. AI Spend and AI Proxy plugins extend Kong’s consumer-and-tag chargeback to coding-agent traffic. Strengths: ops familiarity, plugin ecosystem, Series E stability. Weaknesses: AI-specific normalization is plugin-driven.

What it does:

• Cross-agent normalization through the AI Proxy plugin (Kong 3.6+) and AI Spend plugin with Kong-maintained pricing tables. Mature for Anthropic and OpenAI; newer for Azure and Bedrock.
• Per-agent + per-developer + per-repo dimensions through Kong’s consumer-and-tag pattern. Each agent maps to a consumer; tags carry developer, repo, BU.
• IDE + CLI + terminal coverage by routing every provider endpoint through Kong.
• Chargeback export through logging plugins to Splunk, Datadog, ELK, S3, Kafka. Apptio and CloudHealth via Kafka or S3; schema is the customer’s design.
• Monthly invoice reconciliation is plugin-driven. AI Spend produces recorded cost; reconciliation against invoices is a custom report.
• Optimizer hooks per agent aren’t native; rate-limiting plus routing plugins approximate budget enforcement.
• Vendor breadth is broad through the plugin ecosystem.

Where it falls short:

• AI observability is plugin-driven, not native. Default Konnect dashboard is the API-gateway view, not the cross-agent FinOps view. Plan two to four weeks of platform-team time to assemble the chargeback dashboard.
• AI Spend is younger than rate-limiting and still maturing. Edge cases (Anthropic prompt caching, OpenAI cached input pricing) require manual pricing-table maintenance.
• No self-improving loop.
• Standing up Kong only for AI cost tracking is a heavier lift than alternatives.

Pricing: Kong OSS free. Konnect starts free. Enterprise with AI Proxy, AI Spend, SLA, and support starts ~$1.5K/month; at 2,000-engineer scale expect a six-figure annual contract.

Score: 5.5/7 axes (missing: native cross-agent dashboard, optimizer hooks).

4. LiteLLM: Best for VPC-only cross-agent chargeback

Verdict: LiteLLM is the pick when security requires every prompt to stay in the VPC and FinOps will consume chargeback from a SQL warehouse rather than a hosted dashboard. Source-available under MIT, Python-native, virtual keys per developer per agent. The story is “wire trace data to your Snowflake and build the dashboard there.”

What it does:

• Cross-agent normalization through LiteLLM’s unified completion API across Anthropic, OpenAI, Azure OpenAI, Bedrock, Vertex, Together, Anyscale, Ollama, vLLM. Corner cases (cached input tokens, prompt caching) require maintenance.
• Per-agent + per-developer + per-repo dimensions through team_id, user_id, custom metadata. Cross-agent slicing in your warehouse, not LiteLLM’s UI.
• IDE + CLI + terminal coverage through standard *_BASE_URL redirects.
• Chargeback export through spend-tracking webhooks and database writes. Snowflake/BigQuery export is a SQL-engineer task.
• Monthly invoice reconciliation through the spend-tracking tables; reconciliation against invoices is a custom SQL report.
• Optimizer hooks per agent not native. Pair LiteLLM with traceAI plus fi.opt for the loop; both inside the VPC.
• Vendor breadth is the broadest in the cohort.

Where it falls short:

• The March 24, 2026 PyPI supply-chain compromise (versions 1.82.7 and 1.82.8 exfiltrated SSH keys and cloud credentials per Datadog Security Labs) is the dominant procurement variable. Post-incident response was clean, but most Fortune 500 committees will want the audit, pinned-version policy, and SBOM before signing.
• No native polished dashboard. FinOps lead needs a SQL engineer to build the chargeback view.
• No self-improving loop; pair with traceAI plus fi.opt for the optimization layer.
• Pricing tables for cached input tokens and prompt caching require manual maintenance for some providers.

Pricing: OSS under MIT. Enterprise starts ~$250/month for small teams; six-figure annual at 2,000-engineer scale plus platform overhead.

Score: 5.5/7 axes (missing: native polished dashboard, optimizer hooks; partial credit on procurement).

5. TrueFoundry: Best for one MSA across inference, gateway, and chargeback

Verdict: TrueFoundry is the pick when FinOps and platform leads want one MSA covering inference (self-hosted), gateway (hosted-provider proxy), and chargeback. The consolidation pitch is the wedge: one vendor, one renewal, one compliance set. Trade-off: gateway functionality is solid but newer than the inference-platform core.

What it does:

• Cross-agent normalization through a unified billing schema spanning gateway and inference. Self-hosted vLLM and Ollama report the same dimensions as hosted Anthropic and OpenAI. For mixed shops, the cleanest normalization in the cohort.
• Per-agent + per-developer + per-repo dimensions through a four-tier RBAC hierarchy: tenant > workspace > project > virtual-key. Repo metadata custom-attribute-driven.
• IDE + CLI + terminal coverage through standard endpoint redirects.
• Chargeback export through S3, Snowflake, BigQuery connectors. Apptio and CloudHealth via Snowflake or S3.
• Monthly invoice reconciliation built in for hosted providers and self-hosted GPU hours. Copilot Enterprise seat reconciliation manual.
• Optimizer hooks per agent not native; manual routing-policy changes only.
• Vendor breadth covers hosted (Anthropic, OpenAI, Azure, Bedrock, Vertex) and self-hosted (vLLM, Ollama, TGI, Llama.cpp). Self-hosted breadth is the differentiator.

Where it falls short:

• The Claude Code-specific path (Anthropic Messages API plus tool-use blocks) wasn’t stable in our May 2026 testing for the full feature set. Plan a thorough pilot.
• No self-improving loop.
• Per-agent dashboards less polished than Portkey’s.
• Consolidation pitch is strongest when you actually run self-hosted inference. Pure-hosted shops get less value.
• Smaller community footprint than Kong or LiteLLM; smaller compliance catalog than Portkey.

Pricing: OSS components free. Hosted starts ~$99/month for small teams; Enterprise custom. Six-figure annual at 2,000-engineer scale, value anchored on the consolidation case.

Score: 5/7 axes (missing: optimizer hooks, polished cross-agent dashboard; partial credit on Claude Code stability).

Capability matrix

Decision framework: Choose X if

Future AGI, brief is “one chargeback table for every coding agent and a cost curve that bends down per developer per quarter.” The loop is the wedge; every other gateway here gives a static snapshot. Best when cross-agent spend is $1M+/year and growing.

Portkey, polished hosted dashboard today, attested compliance catalog, PANW acquisition handled contractually. Best when FinOps consumes from the gateway UI, not a warehouse.

Kong AI Gateway, platform team already runs Kong as the REST chargeback gateway and wants to inherit the consumer-and-tag pattern.

LiteLLM, security requires every prompt inside the VPC and FinOps has a SQL engineer to build the dashboard in Snowflake.

TrueFoundry, mixed self-hosted plus hosted inference, and the one-MSA consolidation outweighs per-agent dashboard polish.

Common mistakes when wiring cross-agent cost tracking

How Future AGI closes the loop on cross-agent cost

The other four gateways treat cross-agent cost tracking as an end state: capture cost, normalize it, ship the chargeback table, alert on threshold trips. Future AGI treats it as the input to a per-agent feedback loop.

1. Trace. Every call produces a span via traceAI (Apache 2.0) carrying agent_id, SSO claim, repo, BU, model, token counts, cached-token counts, dollar cost, one schema across Claude Code, Cursor, Codex CLI, Copilot BYOM, Cline.
2. Evaluate. fi.evals scores every call against task-completion, faithfulness, code-correctness, tool-use accuracy with per-agent rubrics.
3. Cluster. Common 2026 patterns: Cursor premium requests retrieve files 60-80% larger than needed; Claude Code calls claude-opus-4-7 on 30% of turns claude-sonnet-4-6 handles equivalently; Codex CLI re-emits boilerplate a deterministic template would produce free.
4. Optimize. fi.opt.optimizers (ProTeGi, Bayesian, GEPA) rewrite per-agent: route Claude Code turns under 10K tokens to claude-haiku-4-5, tighten Cursor’s auto-include, install template scaffolding upstream of Codex CLI, route Copilot BYOM inline completions cheaper.
5. Route. Gateway applies the updated per-agent policy on the next request.
6. Re-deploy. Versioned per-agent. The next 24 hours of eval scores drive automatic rollback if they regress. Chargeback table updates the following day.

Net effect: a 2,000-engineer org with $1.66M/month across five agents typically sees aggregate cost trend down 15-30% within four to eight weeks without changing developer behavior, at the high end, $4M-$6M/year. Per-agent isolation means Cursor can drop 22%, Codex CLI 11%, Claude Code 27%, each tracked and rolled back independently.

The three building blocks are open source: traceAI, ai-evaluation, agent-opt at github.com/future-agi (Apache 2.0). The hosted Agent Command Center adds the cross-agent failure-cluster view, Protect guardrails (~67ms text latency per arXiv 2510.13351), RBAC scoped per-agent and per-BU, SOC 2 Type II certified, AWS Marketplace for EDP drawdown, and BYOC for VPC-only shops.

The question for the FinOps lead and Engineering Director isn’t which gateway is best for Claude Code or Cursor in isolation. It’s which control plane produces one chargeback table finance accepts and one cost curve that bends per agent per quarter, without developer behavior change, and without a migration project when the agent mix shifts in 2027.

What we did not include

Three gateways show up in adjacent listicles but don’t fit the cross-agent cost-tracking brief.

• Helicone. Strong for single-agent observability, but the March 2026 Mintlify acquisition (Mintlify itself acquired by Stripe in late 2025) makes the enterprise review unpleasant.
• Cloudflare AI Gateway. Strong primitives; per-agent normalization is thin as of May 2026 and the chargeback dashboard is the customer’s design.
• Maxim Bifrost. Fastest pilot install in the broader cohort; cross-agent normalization is younger than Portkey’s, four-level RBAC on the roadmap.

All three are worth a second look in Q3 2026.

Related reading

• Best 5 AI Gateways to Monitor Claude Code Token Usage in 2026
• Enterprise Controls for All CLI Coding Agents: A 2026 Gateway Field Guide
• Enterprise LLM Gateway for Claude Code in 2026: A Buyer’s Roadmap
• What Is an AI Gateway? The 2026 Definition
• Best LLM Cost Tracking Tools in 2026

Sources

• Anthropic Claude Code documentation, claude.ai/docs/claude-code
• OpenAI Codex CLI release notes, platform.openai.com/docs/codex
• Cursor IDE team-bridge documentation, cursor.com/docs/team-bridge
• GitHub Copilot Enterprise BYOM documentation, docs.github.com/copilot/enterprise
• Cline, github.com/cline/cline
• Future AGI Agent Command Center, futureagi.com/platform/monitor/command-center
• Future AGI Protect latency benchmarks, arxiv.org/abs/2510.13351 (67ms text, 109ms image)
• Future AGI OSS, github.com/future-agi/traceAI, ai-evaluation, agent-opt (Apache 2.0)
• Portkey AI gateway, portkey.ai
• Palo Alto Networks press release on Portkey acquisition (April 30, 2026), paloaltonetworks.com/company/press/2026
• Kong AI Gateway and AI Spend plugin, konghq.com/products/kong-ai-gateway
• LiteLLM proxy, github.com/BerriAI/litellm
• Datadog Security Labs LiteLLM PyPI supply-chain writeup (March 24, 2026), securitylabs.datadoghq.com
• TrueFoundry LLM Gateway, truefoundry.com/llm-gateway