OpenAI-compatible API
Keep application code stable with model listing, chat completions, completions, and embeddings behind one endpoint.
For public, private, hybrid, and community inference fleets
Xeno
One governed endpoint for every model your team can run.
Xeno turns trusted laptops, workstations, servers, and accelerator hosts into an OpenAI-compatible inference fleet with routing policy, tenant identity, live telemetry, dashboards, and SDKs.
One endpoint
Applications keep one OpenAI-compatible API for chat, completions, embeddings, and model discovery.
Fleet routing
Policy selects eligible clients from advertised hardware, providers, models, health, and load.
Governed access
Tenants, credentials, request history, dashboards, analytics, and telemetry stay in the control plane.
What it does
Make distributed AI capacity usable as one governed service.
Applications use OpenAI APIs with Xeno. The control plane authenticates the request, applies policy, routes according to your policy, and records what happened. Connected clients run beside local runtimes and accelerators, advertise what they can serve, execute routed requests, and report the telemetry operators need to trust the fleet.
Authenticated clients
Trusted clients connect over WebSockets and publish machine inventory, provider health, supported models, and telemetry.
Policy-based routing
Match by model and client rules, then select capacity with RoundRobin, Random, FirstAvailable, LeastRecentlyUsed, or Adaptive routing.
Operational visibility
Inspect request history, headers, bodies, stream counters, routing decisions, host metrics, provider telemetry, and analytics.
Who benefits
Your strongest machine becomes one node in a parallel fleet.
Xeno is not just a way for smaller machines to borrow a GPU. CPU-only machines, gaming desktops, and serious GPU hosts all advertise what they can serve, then applications use one endpoint while Xeno spreads work to the right places.
| Machine type | What you gain | What you contribute | Best fit |
|---|---|---|---|
| CPU-only | Access GPU-powered models running on other trusted systems. | Serve CPU embeddings, smaller models, utility inference, and background jobs. | Laptops, small servers, classrooms, edge boxes, and users without GPU hardware. |
| Desktop GPU | Burst to larger systems when local gaming-class hardware is too small or busy. | Serve smaller chat models, embedding models, and task-specific inference. | Workstations, home labs, developer desktops, and mixed team hardware. |
| Large GPU | Blast independent inference, embedding, eval, batch, and agent workloads across a fleet instead of one queue. | Serve high-end models while offloading small-model and embedding work to cheaper nodes. | GB10-class workstations, accelerator servers, shared lab hardware, research clusters, and production pools. |
Powerful hosts stay focused on GPU-worthy jobs, then parallelize the rest of the workload across the fleet. Applications keep one API instead of tracking which machine has which model today.
How it works
Deploy securely in your environment, or, use our SaaS platform.
Deploy Xeno on-premises for full control of security, policy, and usage. Leverage our SaaS platform to participate in a global network of connected machines. Xeno coordinates capacity across your entire fleet, whether it's public cloud, private cloud, servers, edge devices, or workstations.
Connect nodes
Install the lightweight xeno client on machines with reachable model runtimes or accelerator capacity.
Advertise inventory
Each client reports provider endpoints, supported models, host health, GPU details, and provider telemetry.
Route requests
Applications use OpenAI APIs with Xeno, which then authenticates, checks permissions, applies policy, and routes according to your policy.
Observe outcomes
Operators inspect routing traces, selected clients, timing, token metadata, failures, and fleet utilization.
Cloud control plane
Leverage Xeno SaaS, your own cloud or private server, and securely manage access, credentials, and tenancy for your fleet.
On-premises federation
Deploy internally on desktops, laptops, servers, AI PCs, and give AI applications one governed endpoint for private capacity.
Hybrid and burst
Blend local Ollama or vLLM with OpenAI, Gemini, and compatible endpoints while keeping application code stable.
Dashboards
See the details behind every request.
Full visibility via API or dashboards for both client and server, exhaustive telemetry and capacity management, and model inventory management.
Developer experience
Simple application integration and OpenAI API compatibility
Developers use Xeno like a normal OpenAI-compatible endpoint. Operators can change routing, providers, credentials, and model placement without forcing application teams to chase machine-specific details.
OpenAI-compatible request
curl http://localhost:9000/v1/chat/completions \
-H "Authorization: Bearer $TOKEN" \
-H "Content-Type: application/json" \
-H "x-tenant-guid: ten_default" \
-d '{
"model": "llama3.2:latest",
"messages": [
{ "role": "user", "content": "Explain an inverted index." }
],
"stream": true
}'JavaScript SDK
import { XenoClient } from '@xeno-control-plane/sdk';
const client = new XenoClient({
baseUrl: 'http://localhost:9000',
bearerToken: token,
tenantId: 'ten_default'
});
const models = await client.listOpenAiModels();
const policies = await client.listRoutingPolicies();Python SDK
from xeno_client import XenoClient
client = XenoClient(
"http://localhost:9000",
bearer_token=token,
tenant_id="ten_default",
)
models = client.list_openai_models()
policies = client.list_routing_policies()C# SDK
using System.Collections.Generic;
using Xeno.Sdk;
using XenoClient client = new XenoClient(
"http://localhost:9000",
bearerToken: token,
tenantId: "ten_default");
OpenAiModelList models =
await client.ListOpenAiModelsAsync();
List<RoutingPolicy> policies =
await client.ListRoutingPoliciesAsync();Use cases
For teams turning scattered capacity into a reliable inference layer.
Xeno is for platform teams that need placement, policy, tenancy, and observability around model execution without rewriting every application.
Community GPU networks
Let trusted contributors attach home labs, offices, classrooms, and partner machines to one governed endpoint.
Enterprise AI platforms
Give internal teams a single inference API backed by managed GPU hosts, role-based access, and audit-friendly request history.
Research clusters
Expose heterogeneous workstations as one pool while keeping model inventory and machine details visible to operators.
Private and edge inference
Keep execution near sensitive data or branch users while retaining central visibility and policy control.
On-Premises Quickstart
Clone it. Run Docker. Connect capacity.
Xeno is MIT licensed and available on GitHub. The default Docker deployment starts PostgreSQL, initializes the system, and brings up the server and dashboard for local evaluation.
Docker quick start
git clone https://github.com/jchristn/xeno.git
cd xeno/docker
docker compose pull
docker compose up -d
# Dashboard: http://localhost:9100
# API: http://localhost:9000
# Swagger: http://localhost:9000/swaggerCloud Quickstart
Join the global Xeno network.
Skip the infrastructure. Xeno Cloud is a managed control plane that connects your machines into one governed, OpenAI-compatible fleet, then coordinates capacity across a global network of connected machines. Get central identity, routing policy, live telemetry, and dashboards without operating the server yourself.
Xeno Cloud
app.xenocloud.ai- Managed multitenant control plane, with no server to operate.
- Participate in a global network of connected machines.
- One OpenAI-compatible endpoint across your entire fleet.
- Central identity, routing policy, telemetry, and dashboards.
Public cloud
Private cloud
Servers
Edge devices
Workstations