Self-Hosted AI Infrastructure · OpenAI-Compatible · Open Source
One plane for all your AI
croit aiplane is the infrastructure layer your enterprise AI runs through. It connects applications to models, agents, tools and company data, and holds identity, policy and usage in one place.
Any model. Any tool. Your infrastructure. The OpenAI-compatible clients you already run keep working, unchanged.
A model endpoint is not AI infrastructure
vLLM or SGLang gives you fast inference. It does not know who your users are, which models they may reach, what they spent last month, or how a model gets to your wiki, your Jira and your code. aiplane is the layer that holds all of it: one place where models, agents, tools, data, identity and policy meet, sitting on top of the inference you already run. There is no agent framework to adopt and no application to rewrite. (aiplane is the product previously released as croit LLM Gateway.)
One layer, four things it joins
Above it: your applications
Anything that already speaks the OpenAI or Anthropic API: SDKs, internal services, IDE assistants and CLI agents, plus a built-in chat UI for everyone who does not write code.
Through it: identity and policy
Every request arrives through OIDC sign-in or a per-user token, and is checked against the models, tools and budget that person is allowed before it goes any further.
Inside it: the agent runtime
aiplane runs tools server-side, inside the completion: web search, RAG, MCP connectors, sandboxed code, memory. Your client still receives one ordinary response.
Below it: your models
Self-hosted vLLM, SGLang, Ollama or llama.cpp next to hosted providers. aiplane probes them live, balances across replicas and rides out an outage instead of failing the caller.
Why teams put AIplane in front of their models
Make any model agentic
A model behind vLLM answers prompts. Behind aiplane it searches, reads your documents, runs code and remembers what it was told, for every user and every OpenAI-compatible client.
Private AI, on your own hardware
Inference, prompts, documents and tool execution stay inside your network. Once people have a sanctioned endpoint, public AI services stop being the convenient option.
Connect models to company tools and data
RAG over git, Nextcloud and WebDAV, Google Drive and mailing-list archives. MCP connectors to GitHub, Jira, GitLab and Slack, each authenticated as the individual user.
Models come and go, your aiplane stays
An alias points a name like fast or smart at whatever currently serves it. Swap a model, add a replica, move to new hardware: your applications keep sending the same request.
Private AI comes first
Self-hosting is the default here, not one deployment option among several. aiplane detects what each backend actually is, vLLM, SGLang, Ollama or llama.cpp, and adapts to it: it discovers the context window, matches how that server spells reasoning effort, and works around what it cannot do.
Routing follows how inference behaves. A KV-cache-aware strategy keeps a conversation on the replica that already holds its prefix; least-inflight and weighted round-robin are there when you want them instead. Health probes run every few seconds, and when every replica is busy or down, requests wait and retry rather than returning an error to the caller.
Because the GPUs are yours, their use can be recorded without being charged: mark a self-hosted pool exempt and it never counts against anyone's budget, while the usage still shows up in the dashboards. Public models stay one entry away when a job genuinely needs one.
The agent runs on the plane, so every client gets one
When the model calls a tool, aiplane executes it and feeds the result back into the same completion. The application that made the request receives one ordinary response. A curl script, an IDE assistant and the built-in chat UI therefore get the same agent, with no framework, no orchestration code and no client-side tool loop to maintain. Tools stay switched off until the model asks for the group it needs, which keeps the advertised list short and the choices accurate.
More than 50 built-in tools, plus anything you connect
Web search and reading
Search through SearXNG or Brave, fetch a URL, read a PDF page by page
RAG over your data
Git, Nextcloud, WebDAV, Google Drive and mailing lists, by meaning and keyword at once
MCP connectors
GitHub, Jira, GitLab, Slack and any other MCP server, authenticated per user
Sandboxed code
Python, shell and data tools in single-use gVisor containers, no network by default
Documents
Draft and edit on a versioned canvas, export to PDF, DOCX or PPTX
Memory
What a user tells it once is there in the next conversation, and stays theirs to edit
Runs on their own
Saved prompts fired by a schedule or an inbound webhook, with history and replay
Images and speech
Generate and edit images, transcribe audio, talk to the model, once a backend serves it
Works with what you already run
Inference servers
vLLM, SGLang, Ollama and llama.cpp are detected and profiled automatically. Anything else that speaks the OpenAI wire format is added as a generic backend.
OpenAI-compatible clients
Chat completions, embeddings, images, transcription and speech on the paths your SDKs already call. Change the base URL and the key, and nothing else.
Anthropic API clients
aiplane also serves the Anthropic Messages API, so Claude Code and tools like it can run against your own GPUs under your auth, quotas and usage accounting.
MCP servers
Connect any MCP server by URL. Eight connectors ship in the catalog, among them GitHub, Jira and Confluence, GitLab, Slack and Google Workspace, with OAuth handled per user.
Control that holds across the company
Identity
OIDC with PKCE against Keycloak, Authentik, Entra, Okta or any compliant provider
Roles and groups
Groups mapped from your OIDC claims gate models, tools, skills, RAG collections and connectors
Scoped tokens
Per-user API tokens, stored only as a hash, narrowed to a subset of models and tools
Quotas and budgets
Requests, tokens or spend, over an hour, day, week or month, per user, role, token or model
Usage you can see
Live dashboards of requests, tokens, errors and cost by user, model, backend and source
Data stays put
Conversations, documents and tool execution all live inside your own deployment
One binary, one required setting
aiplane ships as a single Rust binary with SQLite for state, the vector index compiled in, and the web UI served by the same process on the same port. There is no configuration file to write: set a session key, give it a volume, and finish in the browser, where the setup wizard makes you complete a real sign-in before it hands over admin rights. Run it under systemd with podman Quadlets, with Docker Compose, or on Kubernetes with the published Helm chart. Code execution is the one piece that lives outside the binary, in a separate hardened runner service.
From pilot to production, with croit alongside
Start with a pilot that is really yours
We stand aiplane up against your models and your identity provider, so your teams judge it on your own infrastructure instead of on a slide.
Wire it into your data and systems
RAG collections over the repositories and document stores your people actually use, MCP connectors for the tools they live in, roles and quotas that match how your company is organised.
Run it like production
Sizing, hardening and deployment under systemd, Docker or Kubernetes, done by a team that has been operating enterprise and HPC infrastructure for years.
Keep someone on the hook
Commercial licensing, support and a direct line to the engineers who build aiplane, so a layer your company relies on is nobody's side project.
Let's work out what your aiplane looks like
Tell us which models you run today and what you want your teams to be able to do. We will come back with a concrete picture of the setup, the effort and what it costs to run.
Questions people ask first
Open source, backed by croit
Free and open source
Released under AGPL-3.0, with routing, agent runtime, tools, chat UI and access control included. Read the code before you commit to it: no per-seat fees, no held-back edition, no lock-in.
Backed by croit
Built by the team that runs large-scale infrastructure in demanding enterprise and HPC environments. The people who write aiplane are the people who deploy and support it for you.