The AI control plane you operate
Wäg is the layer where your organization's AI decisions are made — once, for every application. Identity, spend, data-handling policy, model selection, agent tool access and audit are resolved in the request path, so they apply to every workload behind the endpoint rather than to the ones that remembered to integrate. It is Kubernetes-native, with its own operator and a Helm chart, and it runs entirely in your infrastructure: no vendor control plane, no telemetry channel, no managed tier.
One control plane for every AI workload in the organization
Product features, internal tools, data pipelines, agents, copilots, notebooks and third-party SaaS all reach models through the same endpoint — and inherit the same identity, budgets, policy and audit without integrating anything.
This is the difference between having an AI gateway and having AI infrastructure. The gateway solves a routing problem for a team. The control plane gives the organization one place where AI is governed, priced and observed — and one place to change when the model landscape moves again next quarter.
Four planes, separated on purpose
An admin UI bolted onto a proxy is not a control plane. Separating these four is what keeps enforcement fast, reporting cheap, and configuration yours.
| Plane | What it holds | Why it's separate |
|---|---|---|
| Data plane | The request path. Stateless Rust replicas: auth, budget checks, policy, cache, routing, invocation, accounting. | Scales horizontally and independently. No admin dependency in the hot path. |
| Control plane | Configuration, identity, policy definitions, budgets, keys, tenants, MCP registry. | Yours, not ours. No vendor tenancy exists to depend on or to compel. |
| Analytics plane | Usage, spend, traces, audit records. | Separated from control storage so reporting load never touches enforcement. |
| Policy plane | Scanner engines, OpenFGA relations, price book. | Pluggable and out-of-process, so a policy change doesn't require a gateway change. |
Everything you'd otherwise build, buy, or go without
Six control surfaces, all enforced in the same request path, all applying to every application behind the endpoint — including ones that were never instrumented.
Cost governance
Stacked spend and rate limits across org → team → user → model → key. Fair-share caps, soft-budget webhooks, chargeback tags, importable price book. With WAEG_CLUSTER=1, budgets fail closed if Redis is lost.
Policy & data protection
An ordered scanner chain pre-call, mid-stream on a rolling window, and post-call. Moderation, PII, or your own webhook. Block, mask or redact per rule.
Agent governance
Identity, run limits, tool policy with human approvals, data-flow control, tool pinning and short-lived credentials — for agents you build anywhere.
Observability & audit Part Enterprise
Every request, routing decision, policy verdict and cost as OTEL traces and Prometheus metrics, plus a signed evidence ledger and residency records. Audit packs, the auditor role and exit export are Enterprise.
Identity & multi-tenancy Part Enterprise
OpenFGA tenancy, and provider keys resolved from your own vault. With Enterprise: OIDC SSO, SCIM 2.0 and corporate IdP tokens authenticating /v1.
Reliability
Same-alias failover, cross-alias fallbacks ordered stronger-first, circuit breakers, and N stateless replicas sharing counters via Redis.
The whole control plane, in one place
Traffic, spend, routing, caching, policy, keys and tenants — served by the Rust binary itself. There is no Node runtime in the gateway.
Runs where you put it
| Shape | For | Needs |
|---|---|---|
| Single binary | Evaluation, a single machine, embedded mode. | Nothing. In-memory state, no external services. |
| Docker Compose | A full control plane on one host, for a team. | Docker. Postgres and Redis run in the stack. |
| Kubernetes (operator) | Production, multi-tenant, HA — run and checked by the Wäg operator from one custom resource. | Postgres, Redis beyond one replica, an object store, and OpenFGA — which the operator can run on your Postgres. |
| Kubernetes (Helm chart) | Clusters where a chart fits the existing pipeline, including OpenShift. | Postgres, OpenFGA, Redis beyond one replica, an object store. The chart never runs the databases. |
| Regional data planes | One control plane, with a gateway per region that keeps that region's traffic data in the region. | A control-plane gateway plus one data-plane gateway per region. Open source. |
| Air-gapped | No internet egress at all. | Offline price book, local policy engines, in-process semantic cache. |
| Wäg Edge (devices) | Local models on members' computers and in mobile apps: Ollama, LM Studio, llama.cpp, Apple Foundation Models, Gemini Nano. | The desktop app or CLI (macOS, Windows, Linux), or the Swift or Android SDK. Enforcement and fleet are Enterprise. |
A first-party operator, not just a Helm chart
Wäg ships its own Kubernetes operator alongside the Helm chart. A WaegInstance resource owns the gateway's Deployments, networking, scaling and monitoring and checks its topology the way the gateway will; providers, models, organizations, budgets, guardrails and keys can be declared as custom resources too.
Declarative instance
A WaegInstance brings up the gateway, its API and worker planes, ingress and monitoring, and can run OpenFGA on your Postgres. A misconfiguration becomes a condition with a reason, not a pod that fails an hour later.
Lifecycle, not just install
Change the image or the spec and the operator rolls the pods; a rotated Secret rolls them too, and a rotated provider key is pushed to the gateway. Shutdown is sized so in-flight requests finish on every rollout.
Scales with demand
API pods scale on CPU or, with KEDA, on in-flight requests read from the gateway itself; workers scale on queue depth. Budgets and rate limits are shared through Redis, which the operator requires past one replica.
Fits how platform teams already work
Sixteen custom resources — the instance, providers, models, organizations, teams, budgets, model access, guardrails, users, applications, keys, MCP servers, residency and Enterprise settings — reviewed, versioned and rolled back like everything else.
Runs on the cluster you already have
The operator needs Kubernetes 1.28 or newer, or OpenShift 4, and installs through its Helm chart, an OLM bundle or a plain manifest. That matters for the sovereignty argument as much as the operational one: "your infrastructure" is only true if it also works in the cluster your organization actually runs.
Sovereignty you don't have to trust us for
Wäg has no control plane of its own. There is no vendor tenancy holding your traffic, no telemetry channel, no licence check phoning home, and no managed tier — so there is no data path anyone could compel, in any jurisdiction, including ours.
Not as a configuration option — as a property of the software. Check it at your own network layer.
- No prompts
- No completions
- No provider keys
- No logs
- No telemetry
- No online licence check
- No usage analytics
No outbound connection is required for the gateway to operate: offline price book, local policy engines, in-process semantic cache. Deployable with no internet egress at all.
The production path runs on Apache-2.0
Routing, HA, failover, caching, hierarchical budgets, the policy chain, the MCP and A2A gateways, agent governance, jobs, realtime, multi-tenancy, the evidence ledger, residency, the console and observability are open source and stay that way. Enterprise adds identity, audit and evidence packs, agent payments, device enforcement and support on top.
One endpoint. Every model. Complete control.
Run it in your own infrastructure
Everything you need to run a control plane in production is Apache-2.0 and stays that way — routing, HA, caching, failover, budgets, policy, MCP, jobs and observability. Self-hosted, no account, no phone-home.
$ docker run -p 4000:4000 <registry>/waeg-gateway:<version>Not a working pull: the images are not public yet. Design partners receive the registry details privately.
Deploy in 5 minutesShape it as a design partner
Wäg is not publicly released yet. We are working with a small cohort of teams running multi-provider AI in production, and serious about governance and sovereignty, to harden the control plane on real workloads.
- Every Enterprise capability included, at no licence cost
- Hands-on migration — we do it with you, including from LiteLLM
- A direct line to the engineers building it, and real influence on what ships next