Enterprise Multi-Model Gateway

Same Results. One-Tenth the Cost.

Top-tier models plan. Open SOTA models execute. One workflow, same output, about 1/10 the cost.

  • ✓Orchestrated savings: top-tier models plan and reason, open SOTA handles execution, output matched
  • ✓Data stays on-prem: fully self-hosted, prompts never reach us; Token Ops keeps usage and cost visible and controllable
  • ✓Compliance you can sign: GDPR / CCPA / DPA ready, client admission enforced
  • ✓Works with the SDK you already have: OpenAI / Anthropic / Gemini / DashScope natively, plus LangChain · LlamaIndex · Vercel AI SDK · CrewAI · OpenAI Agents SDK · Claude Agent SDK — one base_url change
from openai import OpenAI

# One line change: point your SDK at your own gateway
client = OpenAI(
    base_url="https://your-gateway.gatellm.io/v1",
    api_key="your-gateway-api-key",
)

# Existing code unchanged — the gateway routes each request
# to the right model tier (planning vs execution) per your console policy
resp = client.chat.completions.create(
    model="claude-opus-4",  # or gpt-5, deepseek-v3, qwen-plus...
    messages=[{"role": "user", "content": "Plan the architecture"}],
)

Integrated with 100+ LLM Providers · 30+ SDKs & frameworks

OpenAI
Anthropic
Google
DeepSeek
Qwen
ERNIE
Kimi
Zhipu
Mistral
Cohere
"Under extremely stringent compliance requirements, GateLLM not only met our security standards—its cost control capabilities far exceeded expectations. Cost optimization was meant to be a side benefit, but the results were stunning: over 90% reduction in monthly API spend."
— Compliance Lead, Top-Tier Investment Firm
Core Capabilities

One Interface, Mix and Match All Models

From simple model routing to multi-model orchestration, GateLLM provides comprehensive enterprise-grade capabilities.

Multi-Model Routing

One interface to call all models. Intelligent fallback, load balancing, automatic retry.

  • 100+ LLM providers unified API
  • Intelligent fallback routing
  • Load balancing and rate limiting

Composition

Tiered routing by plan mode, identity, or request shape: planning on top-tier models, execution on open SOTA. The gateway rewrites the model name — client code never changes.

  • Plan-mode detection: plan on top-tier, execute on open SOTA — zero client change
  • Identity-scoped model mapping: same model name → different upstreams per key group
  • switch-route rules: redirect image-bearing or special requests to the right model
  • In-agent downgrade: plan locked / non-plan auto-downgrade

Multi-Model Consensus

Run one prompt through several models in parallel and merge the results. The gateway supplies protocol interop and one-key metering for the whole fan-out.

  • Orchestration-side parallel review across N models
  • Gateway protocol interop: non-Anthropic models join Anthropic-only review queues
  • Single access key meters and governs the whole fan-out

MCP Tool Governance

Aggregate external MCP tool servers behind one /mcp endpoint: tool-level ACLs, context budgets, and call auditing. Which tools an agent may use lives in the same permission plane as which models it may call.

  • Multiple MCP servers behind one /mcp endpoint
  • Per-key-group tool allow/deny + label filters
  • Built-in BM25 retrieval when the tool list grows
  • MCP calls / violations / sessions fully audited

Web Search Injection

Give every model web search, uniformly: the gateway retrieves and injects results, synthesizing native search blocks per client protocol — open models get search grounding too.

  • Native search blocks per protocol (Anthropic / OpenAI / Responses)
  • Per-model three-way toggle, graceful degradation on failure
  • Hijacked search excluded from usage billing

Cost Control

Budget management, rate limiting, team cost attribution, mode-aware model policy. Never markup token fees, BYOK with your own keys.

  • Cost attribution by project/feature
  • Soft budget alerts
  • BYOK: pay providers at standard rates
  • Mode-aware model policy (plan/execute, enforceable)

Governance & Integrations

From client access control to CI/CD integration—extend gateway capabilities into your dev and collaboration workflows.

  • Client access control (User-Agent policy)
  • GitHub Actions code review via your own gateway

Office / M365 Add-in

Paid add-on

Use your own model gateway directly inside Excel, Word, PowerPoint & Outlook — self-hosted add-in, data never leaves the network, zero pivot dependency.

  • Excel financial modeling / Word contract review / Outlook inbox
  • Entra SSO + Purview label gating
  • 33 bundled domain skills, paid add-on
Model Mix-and-Match

Model Mix-and-Match: Quality No Single Model Can Deliver

Two real patterns, both built on the capability normalization layer: tiered routing (Composition) and orchestration-side consensus (Multi-Model Consensus).

Composition: Tiered Routing Across Models

Route by plan mode, identity, or request shape: planning stays on top-tier models, execution drops to open SOTA. The gateway rewrites the model name and translates protocols — client code never changes.

  • ✓Plan-mode detection: route planning to top-tier, execution to open SOTA — zero client change
  • ✓Identity-scoped model mapping: same model name → different upstreams per key group / header
  • ✓switch-route rules: redirect image-bearing or special requests to the right model
  • ✓No glue code — protocol translation handled by the gateway
  • ✓Enforceable policy: admins lock model tiers per plan/execute mode, stopping all-top-tier usage
// before-slot transform script (JavaScript) — switch execution model by plan mode.
// Mounted on the entry model in the console; runs before routing.
function transform(body, context) {
    if (context.sourceProtocol !== "Anthropic") {
        return body;
    }
    const EXEC_MODEL = "qwen3.7-max"; // a model name configured in the gateway
    const PLAN = /plan mode is active/i;
    const EXIT = /exited plan mode/i;
    // take the last marker-bearing message: later marker wins
    const messages = body.messages || [];
    for (let i = messages.length - 1; i >= 0; i--) {
        const s = JSON.stringify(messages[i].content || "");
        const inPlan = PLAN.test(s);
        const exited = EXIT.test(s);
        if (inPlan || exited) {
            // not in plan mode → switch execution to the cost-efficient model
            if (exited || !inPlan) context.useModel(EXEC_MODEL);
            return body;
        }
    }
    context.useModel(EXEC_MODEL);
    return body;
}

Multi-Model Consensus

Run one prompt through 2–3 models in parallel, then merge, dedupe, and annotate confidence. The gateway supplies protocol interop and unified metering, so any model joins and all traffic stays centrally governed.

  • ✓Higher accuracy than any single model on high-stakes calls
  • ✓Cross-vendor redundancy — one model's blind spot is another's check
  • ✓Strongest ROI in code review, fraud detection, compliance judgment
[Ensemble Diagram]
Quick Start

Three steps to your first token.

Upgrade from single-model to multi-model orchestration in three steps, no business code rewrite required. Any SDK (OpenAI / Anthropic / Gemini / DashScope) works.

1

Deploy Gateway

One-click Docker launch, or Kubernetes Helm deployment to private environment.

2

Configure Keys

BYOK mode: fill in your existing provider API keys, data stays on-prem, never persisted.

3

Replace Endpoint

Point OpenAI SDK's base_url to GateLLM, call all models with unified interface.

# Just one line change: point base_url to GateLLM
from openai import OpenAI

client = OpenAI(
    base_url="https://your-gateway.gatellm.io/v1",
    api_key="your-gatellm-api-key"
)

# Existing code unchanged, call any model
response = client.chat.completions.create(
    model="claude-opus-4",  # or gpt-5, deepseek-v3, qwen-plus...
    messages=[{"role": "user", "content": "Hello"}]
)
One API

One API. Four protocols. Every modality. Seamless conversion both ways.

Same four protocols on both sides. Convert any-to-any with no glue code, across chat, image, speech, video, realtime voice, embedding, and rerank.

Ingress protocols (your SDK)
OpenAI Chat Completions
Anthropic Messages
Gemini generateContent
DashScope
GateLLM gateway
Egress protocols (model provider)
OpenAI Chat Completions
Anthropic Messages
Gemini generateContent
DashScope
Every modality
chatimagespeechvideorealtime voiceembeddingrerank
Native ingress: OpenAI / Anthropic / Gemini / DashScope SDKs connect directly, no change beyond base_url
Native egress: routes to any provider in its native protocol, not a unified OpenAI envelope re-translated
Any-to-any conversion: ingress A → egress B seamlessly (e.g. Anthropic SDK call → routed to a DashScope-native model, converted to DashScope protocol)
All modalities + embedding/rerank: chat / image / speech / video / realtime voice, plus embedding and rerank protocols unified
Stronger than "OpenAI-compatible": synthorai and others offer three ingress protocols unified to one OpenAI surface; GateLLM offers four ingress + four egress, any-to-any
Wider egress protocol surface: beyond the four major protocol families, 15 upstream protocol shapes in total (incl. AWS Bedrock Converse / Invoke, Realtime, passthrough) — enterprise models on Bedrock and self-hosted models all plug into one gateway
SDK Integrations

Works with the SDK you already have

Point any SDK or framework at the gateway with one line. OpenAI, Anthropic, Gemini and DashScope connect natively; LangChain, LlamaIndex, CrewAI, Vercel AI SDK and 30+ more through the same base_url swap.

1

Point base_url at the gateway

Default https://your-gateway.gatellm.io — whether it includes /v1 depends on the SDK (each example gives the exact value).

2

Swap in a gateway access key

Not an upstream sk-… key — the same access key mounts into whichever header your SDK expects.

3

Use the gateway model name

Whatever you configured in the console — not the vendor's official name.

Authorization: Bearer <key>
OpenAI · DashScope · generic
Bearer prefix case-insensitive
x-api-key: <key>
Anthropic SDK
Authorization also accepted
x-goog-api-key: <key>
Gemini SDK
Authorization also accepted

Official vendor SDKs

Examples ↗

OpenAI / Anthropic / Google SDKs connect natively — only base_url changes

OpenAI SDKAnthropic SDKGoogle GenAI SDKOpenAI-compatible third parties

DashScope native

Examples ↗

Text, image, async video, embedding & rerank through one endpoint

DashScope SDK

Unified SDKs & gateways

Examples ↗

Vercel AI SDK, LiteLLM, Portkey, Semantic Kernel, Spring AI

Vercel AI SDKLiteLLMPortkeyBraintrust / LangbaseSemantic KernelSpring AI

Orchestration frameworks

Examples ↗

LangChain, LlamaIndex, CrewAI, AutoGen, DSPy, Haystack

LangChainLangGraphLlamaIndexCrewAIAutoGen / AG2DSPyHaystackLlama Stack

Agent SDKs

Examples ↗

OpenAI Agents, Claude Agent, Pydantic AI, ADK, Mastra

OpenAI Agents SDKClaude Agent SDKPydantic AIGoogle ADKMastraMicrosoft Agent FrameworkMCP SDK

Realtime & audio

Examples ↗

Realtime WebSocket voice + openai_audio ASR / TTS

Realtime WebSocketopenai_audio (ASR / TTS)

Local / self-hosted

Examples ↗

Ollama, vLLM, llama.cpp as upstreams — keep any client SDK

OllamavLLMllama.cpp serverSGLangText Generation Inference (TGI)LM Studio
OpenAI Agents SDK defaults to /v1/responses

It calls the Responses API, not Chat Completions. If the upstream is openai (Chat), switch explicitly with OpenAIChatCompletionsModel; if openai_response, a string model name works as-is.

LlamaIndex validates the model name against an allowlist

The OpenAI class only accepts families it recognizes and rejects custom gateway names — use OpenAILike (Python) or declare the model info explicitly.

CrewAI is driven by LiteLLM under the hood

base_url isn't a framework parameter — it's the OPENAI_API_BASE env var, and model needs the openai/ prefix.

Whether base_url includes /v1 varies by SDK

OpenAI SDK takes /v1; the Anthropic SDK takes the root (it appends /v1/messages); the Vercel AI SDK's createAnthropic takes /v1 (it appends /messages). Getting it wrong adds or drops a path segment.

# base_url convention differs by SDK — match the one you're using
from openai import OpenAI
OpenAI(base_url="https://your-gateway.gatellm.io/v1")        # OpenAI SDK: /v1

import anthropic
anthropic.Anthropic(base_url="https://your-gateway.gatellm.io")  # Anthropic SDK: root (appends /v1/messages)

# Vercel AI SDK createAnthropic: baseURL ".../v1" (appends /messages) — the reverse
# LangChain ChatOpenAI: base_url="https://your-gateway.gatellm.io/v1"
See all 30+ SDKs & gotchas
Architecture & Security

Capability Normalization: Making Cross-Vendor Mixing Possible

Cross-vendor model mixing rests on the capability normalization layer, which unifies seven coupling points so switching models never means rewriting glue code.

Tool Calling Normalization

OpenAI / Anthropic / Gemini / Chinese models all have different tool calling schemas. We unify them at the foundation, write code once, call all models.

Structured Output Compatibility

Each provider uses different protocols (strict JSON schema, json_mode, tool_use). We unify to a consistent interface.

Prompt Caching Unification

Anthropic cache_control, OpenAI auto-caching, Gemini context—each has different mechanisms. We provide unified caching strategy.

Reasoning Token Adaptation

o1 / Claude thinking / DeepSeek R1 output formats differ. We adapt to each provider's reasoning token protocol.

Multimodal Format Support

vision / audio / file upload protocols differ across providers. We unify multimodal input formats.

Billing Model Abstraction

Each provider's pricing structure differs. We abstract to a unified cost tracking interface.

Data Flow: Stays On-Prem, Never Persisted

In BYOK mode, API keys are stored only in gateway memory, never persisted or transmitted. Requests route through gateway directly to provider official APIs, data never leaves your private network.

SOC 2 controls alignedISO 27001 controls alignedGDPR
Cost Comparison

Why 1/10 the Cost?

Take an enterprise running 1B tokens a day: same workload, same output bar — compare the bill for "top-tier end to end" versus "top-tier plans, open models execute."

Top-tier end-to-end (baseline)
$338K/mo

Claude Opus 4 plans + executes, all top-tier

GateLLM orchestration
$35K/mo

~90% execution on open SOTA, key 10% planning on top-tier

Monthly cost
10% of baseline
Saved per month
$303K
Capability retained
Capability retained 97%

Three Sources of Savings:

  1. 1.BYOK no token markup—you pay providers at standard rates, GateLLM takes no middle cut (aggregators typically add platform and payment fees on top of list price);
  2. 2.Composition—open SOTA models (GLM / Qwen / DeepSeek) carry the bulk of execution (classification, extraction, translation), top-tier closed models (like Claude Opus) only for planning and hard reasoning;
  3. 3.Prompt caching—high-frequency calls hit cache, unit price drops 50%–90%.

Figures are illustrative models based on public pricing, actual savings depend on business scenarios and mix ratios. Pro license fee of $400/mo (2GB single instance) is included in GateLLM plan.

Calculate your own →
View full model catalog →
Token Ops · Token FinOps

Usage you can see, cost you can settle, budgets you can hold

Token Ops tracks who uses what; Token FinOps turns tokens into chargeable, capped money. One control plane makes AI spend as operable as cloud spend.

Token Ops

Usage & Cost Observability

Break every call down by model, access key, and key group, with input / output / cache-hit tokens metered separately at 1-minute granularity.

  • Grouped by model / key / key group
  • Input, output, and cache-hit metered separately
  • 24h / 7d / 30d / custom time series
Token Ops

Client Admission & Audit Trail

Only clients you have approved reach the gateway — allow, throttle, or deny by User-Agent. Every call leaves an auditable record for endpoint governance and compliance evidence.

  • Client access control (User-Agent policy)
  • Call records with log retention (Pro and up)
  • Audit / DLP integration (Enterprise)
Token Ops

Management API (programmatic control)

Enterprise

Manage the gateway via API: create / revoke API keys, set quotas and budgets, query usage and cost, export audit logs — wire it into your internal ops and billing systems.

  • Programmatic API key create / revoke
  • Quotas and budgets via API
  • Usage and cost query API
  • Audit log export
Token FinOps

Your Own Rate Card & Price Snapshots

Enter the private price you negotiated by hand and it becomes authoritative — system refreshes never overwrite it. Each price carries an effective window: schedule price cuts ahead, and edits never rewrite historical cost.

  • Pinned private price shadows auto, never overwritten
  • Snapshots take effect by time window
  • Backfill history / pre-schedule price cuts
  • Token · per-call · per-second billing modes
Token FinOps

Tag-Based Allocation & Chargeback

Tag keys and key groups, then aggregate usage and cost by tag to land token spend on the right cost center. Excel export splits the ledger by model × key for internal showback or chargeback.

  • Free-form tags on keys / key groups
  • Aggregate usage and cost by tag
  • Excel export with 6 sheets (incl. key × model)
  • Ready for internal showback / chargeback
Token FinOps

Cost Quotas & Limits

Set daily and monthly spend caps per key — judged independently on UTC calendar day and month, blocked the moment either trips. Quotas inherit key → group → global, taking the widest across groups.

  • Daily / monthly caps, judged independently
  • Key → group → global inheritance
  • 429 quota_exceeded, Retry-After on daily
Competitor Comparison

GateLLM vs LiteLLM

A source-verified comparison. GateLLM's edge is a single Rust binary, 15-protocol translation, and a YAML-free console; LiteLLM matches on a shared capability baseline and leads on ecosystem breadth.

Both do these well — not a differentiator

If your requirements sit entirely in this layer, either gateway works. Decide on the two layers below, not on this one.

CapabilityGateLLMLiteLLM
API routing · fallback · load balancing✓✓
BYOK, no token markup✓✓
Fully self-hosted, data stays on-prem✓✓
Cross-vendor tool calling normalization✓✓
Structured output (JSON Schema) normalization✓✓
Reasoning / thinking token adaptation✓✓
Cross-model prompt caching✓✓
Web search injection✓✓
MCP gateway (tool aggregation)✓✓
Visual console for configuration✓✓
Enterprise SSO (OIDC + SAML 2.0)✓✓ (Enterprise)
SCIM 2.0 auto-provisioning / deactivation✓✓ (Enterprise)
Audit logs & usage / cost metering✓✓

Where GateLLM is stronger

Verified against the GateLLM core (single Rust binary) and LiteLLM public docs.

CapabilityGateLLMLiteLLM
RuntimeSingle Rust binary · no GC pausesPython process + dependency stack
Protocol translation surface15 protocol shapes; the 4 chat-protocol families (OpenAI / Anthropic / Gemini / DashScope) translate any-to-any, the rest per interop matrixOpenAI-centric envelope + compatible endpoints
Native protocol entrypoints/v1/messages + count_tokens, Gemini generateContent, /v1beta/cachedContents CRUD, /v1/realtime, /mcp — one gateway serves every SDK nativelyOpenAI-compatible endpoint (plus compatible variants)
Prompt caching depthAuto-injects cache breakpoints on OpenAI-protocol calls + cross-protocol mapping + Google cachedContent dedupPasses through cache_control, normalizes usage
Log privacy defaultsRequest logs off by default · 28 credential classes auto-redacted · 7-day default retentionRequest/response logging on; redaction via guardrails
Configuration modeFully in console — no YAML, changes apply liveconfig.yaml-centric
Batch config transactionalityStage → preview full conflict set → single-transaction atomic commitconfig.yaml hot-reload; no conflict preview, no atomic rollback — a half-applied state needs manual cleanup
Per-request rewriteswitch-route rules + JS transform scripts (useModel by plan mode)Custom callbacks / hooks
Billing modesToken / per-call / per-duration + multi-currency (USD/CNY/EUR/JPY/GBP) + custom pricing dimensionsToken-based spend tracking
Upstream SSO credential login✓ (Kiro and vendors without static keys)Static API keys only — vendors without static keys (e.g. Kiro) cannot be onboarded
Capability metadata registry✓ (drives auto-injection & degradation)Per-provider hardcoded adapters — new-model capability drift needs a code change
LicensingFlat per instance / memory, no seats, no token markupFree OSS; Enterprise is usage-priced
Multi-SDK coexistenceOne gateway natively serves OpenAI / Anthropic / Gemini / DashScope SDKs — client and upstream protocols may differOpenAI-centric entrypoint; non-OpenAI SDKs go through compatibility shims
Upstream key pooling & sticky bindingWeighted FNV-1a hashing pins each caller to one key, fails over to the next untried key, weight=0 standby keysSingle-key-per-provider; no weighted pool or failover
Crash-safe billingPre-deduct → settle → refund with an in-flight ledger — correct across process crashesPost-hoc spend tracking; a crash can drop or double-count usage
Cost quota hard gateDaily / monthly independent cycles, 429 quota_exceeded + Retry-After, key → group → global inheritanceBudget alerts only — spend can overrun before a human acts
Version support windowN-1 + LTS branch (see /lifecycle)Last 4 minor lines only, no LTS branch
Support SLAPriority support included in the flat licenseStandard tier has no response-time commitment; 24/7 SLA is a paid add-on (Sev0 1h / Sev1 6h)

Verified against each product's official docs as of 2026-09-04 (docs.litellm.ai / docs.gatellm.io). Some LiteLLM capabilities require an Enterprise license; details can drift — check the sources before procurement.

View full comparison →
What you actually get

What you actually get.

The three things procurement cares about, settled before the price: a DPA legal can sign, a bill that can't run away, and prompts that never reach us.

A DPA your legal team can sign

GDPR and CCPA ready, with a DPA your legal team can actually sign. Self-hosted — data never leaves your perimeter — with Enterprise SSO (OIDC / SAML 2.0) and SCIM 2.0 provisioning included.

GDPRCCPADPASSOSCIMAudit trail
View DPA →

A bill that can't run away

BYOK: pay providers at standard rates — no token markup, no per-seat fees. Hard quota caps per key and project keep a runaway script from outrunning your budget.

No token markup0 per-seat feesPrompt cacheHard quota caps30-day refund

Your prompts never reach us

Fully self-hosted — your prompts and completions never enter our systems at all. BYOK keys live only in gateway memory; requests go straight to provider APIs, never leaving your network.

Data stays on-premKeys never persistedTLS 1.3Client admissionSelf-selected models
Pricing

Fully Self-Hosted · Single Instance 2GB · Never Markup Token Fees

BYOK (bring your own keys) — you pay providers at standard rates. We license a single 2GB instance, never by seats or token markup. Larger memory or multi-instance goes through Enterprise.

Free

$0

Fully self-hosted · Single license

  • ✓100+ LLM routing · Fallback · Load balancing
  • ✓Multi-model consensus (parallel review · merge · annotate)
  • ✓Cross-vendor model mixing · in-agent downgrade (plan locked / non-plan auto-downgrade)
  • ✓Client access control (User-Agent policy)
  • ✓Prompt caching
  • ✓BYOK (bring your own keys, no markup)
  • ✓512MB storage · SQLite · Single license deployment
  • ✓GitHub Actions code review via your own gateway
  • ✓No log retention
Recommended

Pro

$400

/ month · 2GB single instance (fixed cap)

  • ✓All Free features
  • ✓2GB memory · single instance (fixed cap, no add-on)
  • ✓Log retention
  • ✓Enterprise SSO (OIDC: Azure AD / Okta / generic, plus SAML 2.0 + SCIM)
  • ✓PostgreSQL · 2GB memory
  • ✓Email / ticket support

100% refund within 30 days if unsatisfied

Enterprise

from $400/GB

By memory capacity · Billed annually · 30-day refund

  • ✓All Pro features
  • ✓Capacity-based billing (nodes × memory, flat $400/GB/mo)
  • ✓Multi-node / cluster deployment
  • ✓GitHub Actions code review via your own gateway
  • ✓Microsoft 365 add-in (Excel/Word/PPT/Outlook, paid add-on)
  • ✓Extended log retention
  • ✓Priority support response
  • ✓Compliance (Audit / DLP)
  • ✓Management API (programmatic API key · quota · usage query · audit export)

Need more capacity or a custom setup? Contact us →

Feature Comparison

CapabilityFreeProEnterprise
Multi-Model Routing · Fallback · Load Balancing✓✓✓
Cross-Vendor Model Mixing (Planning/Execution by Vendor)✓✓✓
In-Agent Model Downgrade (plan locked / non-plan auto-downgrade)✓✓✓
Multi-Model Consensus (orchestration-side)✓✓✓
Prompt Caching✓✓✓
BYOK (Bring Your Own Keys, No Markup)✓✓✓
Memory Tier512MB2GB (fixed)Custom
Storage / Database512MB · SQLitePostgreSQL · 2GBPostgreSQL + Redis Cluster
Deployment Scale1 instance1 instance · 2GBMulti-Node / Cluster
Throughput per GB (reference)—2GB ≈ 200M TPM / 1,000 RPM≈ 100M TPM / 500 RPM per GB
Log RetentionNoneRetainedExtended Retention
SSO (OIDC / SAML 2.0)—✓✓
SCIM 2.0 auto-provisioning—✓✓
Compliance (Audit / DLP)——✓
Management API (programmatic key · quota · usage · audit)——✓
Self-owned rate card / price snapshots (incl. private pricing)✓✓✓
Cost quotas (daily / monthly, three-level inheritance)✓✓✓
Support ResponseCommunityEmail / TicketPriority Response
Mode-Aware Model Policy (plan/execute, enforceable)✓✓✓
Client Access Control (User-Agent policy)✓✓✓
GitHub Actions Code Review (via your gateway)✓✓✓
Microsoft 365 Add-in (Excel/Word/PPT/Outlook, self-hosted)—Add-onAdd-on
Purview sensitivity-label gating (addin.access / file.upload)——✓
FAQ

FAQ

Start Building Your Multi-Model AI Apps

Fully self-hosted · Single instance 2GB · Never markup token fees.

One API, every modality · Fully self-hosted · Data stays on-prem · Never markup token fees