Is LiteLLM open source?

The core of the repository is under the MIT License according to the LICENSE file. The enterprise/ folder is governed by a separate BerriAI Enterprise License according to the same file; per the license text, production use of these enterprise features requires a valid enterprise license for the appropriate number of user seats.

Do I need an Enterprise license for SSO with LiteLLM?

According to the LiteLLM documentation, SSO is free for up to 5 users from version 1.76.0; beyond that, an enterprise license is required. JWT-based authentication for API requests also requires an enterprise license per the documentation. In the innFactory AI Gateway, Entra ID, OIDC and all seven roles are included in every license tier.

Does LiteLLM measure the working time of coding agents such as Claude Code?

LiteLLM documents guides for Claude Code, Codex CLI, Cursor, Gemini CLI and further tools and attributes the traffic that passes through the proxy to keys, teams and users. A local companion that measures agent time per repository and also captures subscription sessions is not described in the LiteLLM documentation as of 26 September 2026.

Does LiteLLM support more model providers than the innFactory AI Gateway?

Yes. LiteLLM states more than 140 providers by its own account; the innFactory AI Gateway supports 13 provider types, including Azure OpenAI, AWS Bedrock, Anthropic and Gemini (also via Vertex AI), STACKIT and IONOS. STACKIT and IONOS are not documented as dedicated providers in the provider list of the LiteLLM documentation.

Does the innFactory AI Gateway run in my own infrastructure like LiteLLM?

Yes. Both products run in the customer's infrastructure. LiteLLM documents Docker, Helm, Kubernetes and Terraform modules; the innFactory AI Gateway is deployed as a container into your cloud tenant, for example on Azure Container Apps, AKS, STACKIT or any Kubernetes. innFactory does not operate it as SaaS.

LiteLLM Alternative: innFactory AI Gateway vs LiteLLM

Key facts (as of 26 September 2026):
LiteLLM by BerriAI is, per its own documentation, a self-operated LLM proxy with an admin UI (Docker, Helm, Kubernetes, Terraform) whose repository core is under the MIT License according to the LICENSE file, while the enterprise/ folder is governed by a separate BerriAI Enterprise License.
The innFactory AI Gateway is deployed into the customer’s cloud tenant and bundles cost centers with per-member caps, budgets in euros and a companion that measures the agent time of Claude Code, Codex and OpenCode per repository, including subscription usage.
Per the documentation, LiteLLM captures the traffic that passes through the proxy and attributes it to keys, teams and users; SSO is free for up to 5 users from version 1.76.0 and requires an enterprise license beyond that, and a local companion for agent time per repository is not described in the LiteLLM documentation as of 26 September 2026, which is exactly what the innFactory AI Gateway companion does.
LiteLLM fits when you need a code-extensible proxy for models from many providers, including small ones, plus SAML, SCIM or an external secret manager; the innFactory AI Gateway fits when cost centers in euros, seven roles without a license threshold and the agent time of coding agents including subscription sessions come first.

LiteLLM describes itself as “The AI Gateway for platform teams” and as an “Open-Source AI Gateway & LLM Proxy” (litellm.ai). LiteLLM by BerriAI positions itself, by its own description, as an open-source option for an LLM proxy across multiple model providers. We say it plainly: LiteLLM is a good product. Provider coverage is very broad, the documentation is extensive, and the ecosystem of integrations is large.

This comparison is therefore not a takedown but a classification. Both products run in the customer’s infrastructure, both speak the OpenAI, Anthropic and Gemini dialects, both enforce budgets. The real decision: Do you need a proxy that is as broad as possible and extensible in code, with an enterprise tier for identity and governance, or an infrastructure component that treats cost centers, roles, guardrails and the working time of coding agents as core functions from the start? All statements about LiteLLM refer to its public documentation as of 26 September 2026.

What LiteLLM is

LiteLLM by BerriAI is an LLM proxy with an admin UI that forwards requests in OpenAI format or native format to a large number of model providers. The core of the repository is under the MIT License according to the LICENSE file. The same file makes clear that all content in the enterprise/ folder is governed by a separate BerriAI Enterprise License. According to its text, copying and modifying for development and testing is allowed without a subscription; production use of the enterprise features requires a valid enterprise license for the appropriate number of user seats. The vendor compares the two tiers as “Free” and “Enterprise” on its features page.

Technically, the proxy is Python-based today according to the documentation; PostgreSQL is named as the production database. According to the LiteLLM documentation, the proxy is in a gradual migration from Python to a Rust core; the vendor publishes its own progress report on this. The innFactory AI Gateway is also written in Rust. That is an architecture decision, not a distinguishing feature.

Operating model: SaaS, self-hosting or infrastructure in your own tenant

The two products are close here. LiteLLM is self-operated according to its deployment documentation: Docker images under ghcr.io/berriai, two Helm chart variants, Kubernetes manifests, Terraform modules for AWS ECS Fargate and Google Cloud Run, plus deploy buttons for Render and Railway. On the data flow, the vendor writes: “No data or telemetry is stored on LiteLLM Servers when you self-host”. The enterprise page lists “Self-hosted, in your infra” and “Air-gapped deployment”.

The innFactory AI Gateway is likewise deployed into the customer’s cloud tenant, with Azure Container Apps or AKS as the reference path, alternatively STACKIT or any Kubernetes. The backend is a single binary in a container plus a dashboard image; the database is PostgreSQL (for example STACKIT PostgreSQL Flex), MongoDB or Azure Cosmos DB. innFactory does not host the gateway as SaaS; innFactory GmbH, a Microsoft CSP, supports the rollout and can provide the Azure subscription. In both cases the data path stays in the tenant. LiteLLM ships Helm charts; the innFactory AI Gateway currently does not.

Identity, SSO and roles

LiteLLM documents SSO for Okta, Google, Microsoft Entra ID and a generic OAuth client, plus SAML 2.0 and SCIM on separate pages. The conditions are clearly stated: “SSO requires a LiteLLM Enterprise license” and “From v1.76.0, SSO is free for up to 5 users. Beyond that, an enterprise license is required.” For JWT-based authentication of API requests (Keycloak, Google Cloud OIDC, Azure AD, generic OIDC issuers) the documentation states: “JWT-based Auth requires a LiteLLM Enterprise license.” The documented roles are proxy_admin, proxy_admin_viewer, internal_user and internal_user_viewer, and admin and user at team level.

The innFactory AI Gateway connects to Microsoft Entra ID or generic OIDC (Keycloak documented, AWS Cognito claims handled); OIDC/JWT on the proxy path is opt-in, and trusted-header auth is available for LibreChat and CompanyGPT. There are seven roles: Owner, Admin, Auditor (reads everything), Finance (costs and margins), Security (guardrails, audit log, denials), Member and Guest. Guests are assigned automatically for logins outside the allowed e-mail domains and get no proxy access. IdP groups can be mapped to six roles, and cost centers have their own administrators. All of this is included in every license tier. SAML and SCIM are currently not included in the innFactory AI Gateway; anyone who strictly needs them will find them documented by LiteLLM.

Cost control and AI FinOps

According to its documentation, LiteLLM sets budgets globally and per team, team member, key, project ("[Beta] Project Management"), tag, model access group and customer. Budgets are hard stops: when exceeded, the proxy responds with an error (“Budget has been exceeded!”); in addition there are “Team Soft Budget Alerts”. Time windows are defined via budget_duration in seconds to days, for example 30d. Attribution is by end user, team, key, free-form tags, model and provider; the x-litellm-response-cost header shows the cost per request. Spend is served by JSON endpoints such as /global/spend/report; a CSV export is not documented on the cost-tracking page. USD is the only documented currency.

The innFactory AI Gateway is tailored to controlling processes here. Four independent gates, organization (monthly), cost center (monthly plus daily and weekly windows, in pool or per-user mode with per-member caps), user and API key, respond with HTTP 402 and error code E4006 when exhausted; optionally a budget fallback model steps in instead of the rejection, while per-member caps always remain hard stops. On top come per-model caps, TPM and RPM rate limits (429, E4007), alerts at 80 and 90 percent and the budget_exceeded event, which can trigger a flow or webhook.

Costs are attributed by user, key, team, cost center, model, provider, tool, repository, origin and billing source (gateway or subscription) and displayed in euros at the ECB daily rate; list prices come from ai-prices.eu and are applied only after review by an admin. Every buffered response carries the x-aigateway-response-cost header; Insights provide breakdowns and time series per dimension as well as a CSV export including agent and LLM time.

Coding agents, subscriptions and agent time

Credit first: LiteLLM documents a long list of client guides, including Claude Code (with a guide for routing the traffic of a Claude Code Max subscription through the proxy), Claude Desktop (Cowork), OpenCode, OpenClaw, Cursor, GitHub Copilot in VS Code, Gemini CLI, Qwen Code CLI, OpenAI Codex CLI, Retool Assist and Open WebUI; Roo Code is named as a further tool for usage tracking.

The difference lies in what is measured. Everything LiteLLM captures is traffic that passes through the proxy; per the documentation it is attributed to keys, teams, users and customers, complemented by the beta “Project” object. A local companion that measures an agent’s working time per repository and also captures subscription sessions that never touch the gateway is not described in the LiteLLM documentation as of 26 September 2026.

That is exactly the job of the aigw companion. The small background service on the developer machine (Linux, macOS, Windows) reads the local session logs of Claude Code, Codex and OpenCode and reports agent time (the agent’s active working time, with unattended runs counting fully), LLM time and token classes, per repository, user, tool and cost center. It detects whether a session ran through the gateway or on the tool’s subscription (Claude Max, ChatGPT or Codex plan); subscription usage is valued at list price as “shadow tokens” but never billed, budgeted or rate-limited, and always shown separately. Repositories are mapped to a cost center by rules on repository, owner or host.

Rollout works via device-code login or with enrollment tokens for unattended distribution (Intune Win32 app, macOS shell-script policy, Linux script). aigw run claude|codex|opencode launches a tool with a short-lived proxy token without touching the tool’s configuration. For proxy mode there are six setup generators: Claude Code, Codex, OpenCode, Cowork, VS Code Continue and VS Code Copilot. In fairness: the companion does not cover Cursor, Windsurf, Cline, Copilot CLI or Gemini CLI.

Providers, dialects and models

Here LiteLLM is simply broader. The vendor states “140+ LLM providers” on its homepage and “2,600+ models across 140+ providers” on its model catalog; the numbers differ between pages and should be read as approximate vendor claims. European providers such as Mistral AI, Aleph Alpha, Nscale and OVHcloud AI Endpoints are documented as well. STACKIT and IONOS are not documented as dedicated providers in the provider list of the LiteLLM documentation. As dialects, LiteLLM documents OpenAI-compatible endpoints, Anthropic and Gemini natively, the Responses API, Realtime, audio, image generation and embeddings.

The innFactory AI Gateway supports 13 provider types: OpenAI, Azure OpenAI, Azure AI Foundry, Anthropic (direct or via Vertex), Gemini (AI Studio or Vertex including the EU endpoint), Mistral, AWS Bedrock (including Bedrock Mantle), STACKIT, IONOS, Ollama, LM Studio, ElevenLabs and any OpenAI-compatible endpoint. Inbound, it speaks the OpenAI, Anthropic and Gemini dialects, plus realtime WebSocket for OpenAI, Azure OpenAI, ElevenLabs and Gemini Live as well as audio, embeddings, images, OCR and batches. Anyone who needs a niche provider is better served by LiteLLM; anyone who wants the sovereign German providers as first-class providers finds them in the innFactory AI Gateway.

Governance: guardrails, MCP, routing and Flow Builder

For guardrails, LiteLLM relies on a broad network of named providers, namely Presidio, Aporia, Lakera, AWS Bedrock Guardrails, Guardrails AI, Azure Content Safety and TypeSafe, complemented by a built-in content filter, a Tool Permission Guardrail, a generic guardrail API and the beta feature “Guardrail Policies”. Execution modes are pre_call, post_call, during_call and logging_only for shadow scanning. According to the features page, “Set Guardrails per request”, “Default-on Guardrails” and “Set Guardrails by Key/Team” sit in the Enterprise column. For MCP, LiteLLM documents a centralized MCP gateway with namespacing per server, OAuth 2.0 discovery with PKCE, API key, Basic Auth, AWS SigV4 and forwarded headers. For routing, Simple-Shuffle, latency-, usage- and cost-based strategies, least-busy and custom strategies via a class are available, plus fallbacks, session affinity and cooldowns; caching is exact-match and semantic. A visual flow builder with nodes is not documented on the pages reviewed; a Model Compare Playground for up to three models is documented.

The innFactory AI Gateway brings nine guardrail rule types as its own engine: secret detection, PII block or redact with de-redaction, banned keywords, token and cost limit, Azure Content Safety, prompt injection, denied topics, groundedness and external webhook, with shadow mode, mid-stream redaction, a GDPR preset and a /check dry run, in every license. The MCP proxy exposes Streamable HTTP servers under /mcp/servers/{name} with eight upstream auth modes (among them OAuth client credentials, per-user OAuth PKCE, Entra on-behalf-of, AWS SigV4), named toolsets, semantic tool search and guardrails on tool arguments and results. Routing includes an auto-router by prompt complexity, aliases, cross-provider fallbacks, deployment groups and an optional cache.

The Flow Builder is the part LiteLLM does not document in this form: a visual graph with nine strategies (among them failover, least_cost, cost_cascade, strategy_llm), guardrail nodes with pass, block and fail branches, and event triggers such as budget_exceeded that fire webhooks. A flow is callable like a model and bills the same budgets.

What LiteLLM does better

Provider breadth: More than 140 providers by its own account and a public, continuously maintained model catalog, far more than 13 provider types.
Extensibility in code: Custom guardrails via apply_guardrail, custom routing strategies via CustomRoutingStrategyBase, a generic guardrail API.
Secret managers: AWS KMS, Azure Key Vault, Google KMS, HashiCorp Vault and CyberArk per the enterprise documentation. The innFactory AI Gateway encrypts provider credentials AES-256-GCM in its own store; external secret managers are not part of the current scope.
Guardrail providers: Presidio, Aporia, Lakera, Bedrock Guardrails, Guardrails AI, Azure Content Safety and TypeSafe as named integrations.
MCP authentication: OAuth 2.0 discovery with PKCE, Basic Auth and further modes are described broadly in the MCP documentation.
Client guides: More than ten documented integrations from Claude Code to Open WebUI.
Deployment artefacts: Two Helm chart variants, Terraform modules for AWS and GCP in the Terraform Registry, Render and Railway buttons.
SAML and SCIM: Described on dedicated documentation pages.
Transparency: Public engineering blog, published progress of the Rust migration, documented support SLAs and version policy.

When LiteLLM is the right choice

Your platform must reach models from many providers, including small ones.
Your team wants to extend guardrails, routing and hooks in Python itself.
You need SAML, SCIM or an external secret manager such as HashiCorp Vault.
You use many different coding tools and need a documented proxy guide for each.
You want Helm charts or ready-made Terraform modules for ECS and Cloud Run.

When the innFactory AI Gateway is the right choice

The business side wants cost centers with pool or per-user budgets, daily and weekly windows and reports in euros.
SSO, seven roles and guardrails should be included in every tier without a license threshold.
You want to know how much agent time Claude Code, Codex and OpenCode deliver per repository, including subscription sessions that never pass through the gateway.
STACKIT, IONOS or Azure AI Foundry should be first-class providers.
Routing and guardrails should be maintained as a visual flow, not as code.
You use CompanyGPT or plan to, and want to set up identity, cost centers and guardrails only once.

Comparison at a glance

Criterion	LiteLLM (per documentation, as of 26 Sept 2026)	innFactory AI Gateway
License	Core MIT; `enterprise/` under BerriAI Enterprise License, production use with enterprise license	Monthly license by user count, 199 to 749 EUR excl. VAT
Operation	Self-hosting via Docker, Helm, Kubernetes, Terraform	In the customer’s cloud tenant; rollout support by innFactory
SSO	Enterprise license; free up to 5 users from v1.76.0	Entra ID and OIDC in every license
API auth via JWT/OIDC	Enterprise license	Opt-in, in every license
Roles	proxy_admin, proxy_admin_viewer, internal_user, internal_user_viewer; team: admin, user	Owner, Admin, Auditor, Finance, Security, Member, Guest
Budgets	Global, team, team member, key, project (beta), tag, access group, customer; hard stop	Organization, cost center, user, key; 402 E4006 or fallback model
Currency	USD documented	EUR at ECB daily rate
Export	JSON endpoints; CSV not documented	Insights and CSV export incl. agent time
Coding agents	More than ten client guides; captures proxy traffic	Six setup generators; companion measures agent time per repository incl. subscription sessions
Providers	More than 140 by its own account	13 provider types incl. STACKIT, IONOS
Guardrails	Named third-party providers plus content filter; parts in the Enterprise column	Nine rule types, shadow mode, in every license
Visual flow builder	Not documented	Nine strategies, guardrail nodes, event triggers

Conclusion

LiteLLM is a good product. Anyone looking for a broadly extensible open-source proxy with a very large number of providers has a solid foundation in it, provided the team plans for the enterprise license for SSO beyond five users, JWT auth and parts of the guardrail controls from the outset.

The innFactory AI Gateway sets a different focus: an infrastructure component in your own tenant in which cost centers in euros, seven roles, an own guardrail engine, an MCP proxy and the Flow Builder are part of every license, and which, with the companion, answers a question a pure proxy cannot: how much working time do our coding agents deliver per repository, even when they run on a subscription?

Natively integrated with CompanyGPT, one reusable stack

The innFactory AI Gateway is natively integrated with CompanyGPT: the same budgets, cost centers and guardrails apply to chat, agents and add-ons. Identity (Entra ID or Keycloak), cost centers, guardrails and the MCP registry form one stack that is reused across CompanyGPT, the gateway and every application that runs through the gateway. The gateway can just as well run standalone, for example as the basis for internal tools and coding agents. Further comparisons are listed under all comparisons; the product page is AI Gateway.

Sources

Retrieved on 26 September 2026:

LiteLLM homepage — https://www.litellm.ai/
LiteLLM Enterprise — https://www.litellm.ai/enterprise
LiteLLM Features: Free vs Enterprise — https://www.litellm.ai/features
LiteLLM repository — https://github.com/BerriAI/litellm
LiteLLM LICENSE (MIT, note on enterprise/) — https://raw.githubusercontent.com/BerriAI/litellm/main/LICENSE
BerriAI Enterprise License — https://raw.githubusercontent.com/BerriAI/litellm/main/enterprise/LICENSE.md
Deployment documentation — https://docs.litellm.ai/docs/proxy/deploy
Production documentation — https://docs.litellm.ai/docs/proxy/prod
Data Security — https://docs.litellm.ai/docs/data_security
Rust migration — https://docs.litellm.ai/rust-migration
Admin UI SSO — https://docs.litellm.ai/docs/proxy/admin_ui_sso
JWT-based Auth — https://docs.litellm.ai/docs/proxy/token_auth
Users and roles — https://docs.litellm.ai/docs/proxy/users
Team Budgets — https://docs.litellm.ai/docs/proxy/team_budgets
Customers — https://docs.litellm.ai/docs/proxy/customers
Cost Tracking — https://docs.litellm.ai/docs/proxy/cost_tracking
Enterprise features — https://docs.litellm.ai/docs/proxy/enterprise
AI Tools — https://docs.litellm.ai/docs/ai_tools
Claude Code Max Subscription — https://docs.litellm.ai/docs/tutorials/claude_code_max_subscription
OpenAI Codex CLI — https://docs.litellm.ai/docs/tutorials/openai_codex
Providers — https://docs.litellm.ai/docs/providers
Model catalog — https://models.litellm.ai/
Guardrails Quick Start — https://docs.litellm.ai/docs/proxy/guardrails/quick_start
Tool Permission Guardrail — https://docs.litellm.ai/docs/proxy/guardrails/tool_permission
Guardrail Policies — https://docs.litellm.ai/docs/proxy/guardrails/guardrail_policies
Realtime Guardrails — https://docs.litellm.ai/docs/proxy/guardrails/realtime_guardrails
LiteLLM Docs: Custom Guardrail — https://docs.litellm.ai/docs/proxy/guardrails/custom_guardrail
LiteLLM Docs: Bedrock Guardrails — https://docs.litellm.ai/docs/proxy/guardrails/bedrock
LiteLLM Docs: TypeSafe Guardrail — https://docs.litellm.ai/docs/proxy/guardrails/typesafe
MCP — https://docs.litellm.ai/docs/mcp
Routing — https://docs.litellm.ai/docs/routing
Caching — https://docs.litellm.ai/docs/proxy/caching
Model Compare UI — https://docs.litellm.ai/docs/proxy/model_compare_ui

Note on the information: All statements about other vendors’ products are based on their publicly available documentation as of the stated date. Vendors continuously develop their products, features and terms — the vendor’s current information always prevails. If any statement appears outdated or incorrect to you, please drop us a line at info@innfactory.ai; we will review and correct it promptly. This comparison does not replace legal or data-protection advice in individual cases.

AI Gateway vs. LiteLLM: Broad Open-Source Proxy or Governance and FinOps Gateway in Your Own Tenant?