One door for all your AI.
Every app, agent, and person reaches AI - local models on your own hardware or external providers you bring keys for - through a single gateway that owns identity, authorization, routing, metering, and observability.
# point any OpenAI client at the gateway
curl https://aiselu.your-org/v1/chat/completions \
-H "Authorization: Bearer $AISELU_KEY" \
-d '{
"model": "gemma-3-4b",
"messages": [{ "role": "user",
"content": "Namaste" }]
}'
# → routed to a local node. metered. governed.The whole platform, in one plain console.
Catalog a model, grant it to a tenant, and watch the fleet that serves it - all from a single admin view. The gateway is stateless underneath, so it scales to as many replicas as you need.
Run models on your own hardware.
A serving agent runs one per machine. It downloads the models you name, starts an OpenAI-compatible server for each, restarts anything that crashes, and tells the gateway what it is running - every few seconds.
- Chat & text, embeddings, and audio (Whisper + Kokoro)
- Downloads once at startup, then never waits
- Add a machine, its models appear in the fleet
You decide who can reach what.
A live node advertising a model does not make it usable. A platform admin catalogs each model and grants it to a tenant - grants are admin-only, so a tenant can never grant itself a model. Register, grant, or revoke in one place.
- Local and external models in one catalog
- Per-tenant grants, revocable at any time
- Aliases and rewrites resolve to the right target
A door for everyone who touches AI.
Members sign in with email and password - never a key. They land in a playground that runs on their own session, mint long-lived keys for external apps, and, if they are admins, manage members. Every call is attributed and metered to their tenant.
- Playground on your own session - no key pasting
- Mint API keys shown once, stored only as a hash
- The key never reaches the browser
Every request runs one chain.
From the credential a caller presents to the adapter that answers it, each step is checked in order - and a failure at any step is a distinct, metered, structured error.
RBAC, five roles
Platform admin and viewer govern the fleet and catalog; tenant admin, developer, and viewer govern one tenant. A tenant can never grant itself a model.
Quotas that hold the line
Assignable per tenant, service account, or user - the most restrictive wins. External-cost models hard-cut at 100%; local models follow a soft ladder.
Two credentials, never mixed
Who a human is (email + password → session) is separate from what a request may do (a metered API key). The playground uses the session; keys are for apps.
Every surface, one schema.
Point your existing SDK at the gateway. It speaks the formats your tools already know - and each surface is authorized, routed, and metered the same way.
Nothing leaves without a trace.
Every request is attributed to a principal and metered to a tenant, with the split between free local serving and billed external calls kept honest on every hop.
- Usage and spend per tenant, always current
- Free local serving vs. billed external, split out
- Structured, metered errors at each step of the chain
- Signed, httpOnly sessions - keys never touch the browser
Put every AI request behind one governed door.
Bring up the gateway, a serving machine, and your first request in an afternoon - the runbook walks the happy path top to bottom.
Answers before you wire it in.
Anything deeper lives in the runbook and the gateway docs.