Every prompt to the right model. Automatically.
LinuxAir predicts how well each of your models will answer each request, then routes it to the cheapest one that's as good as your best. Quality first, savings automatically — no rules to write, no router to retrain.
Works with the providers you already use
Everything that happens between your app and a model.
Quality-guarded routing
Predicted quality per model for this exact prompt, a band you control, and the cheapest model inside it wins.
Add a model, it competes
Pick from your provider's catalogue. Prices and context windows fill themselves in. No retraining, ever.
Weak answers get caught
A judge checks trade-downs and retries on a stronger model when they fall short.
PII redaction
Emails, cards, national IDs and your own patterns never reach a provider.
Spend caps
Daily and monthly budgets per workspace and per key, with alerts before you hit them.
Shadow tests & evals
Try a model against real traffic before you trust it, and score them on your own prompts.
One base URL. Your keys. Your code unchanged.
Routing that grows with your traffic.
For startups
Ship on the strongest model, then cut the bill without touching your prompts. Free credits on signup, no card, and savings visible on your own traffic within a day.
See pricingFor enterprises
Self-host it, redact sensitive values before prompts leave, set spend caps per team and per key, and give everyone roles, audit logs and reports that stand up in a review.
Self-hostingOne model for every prompt is the most expensive way to be average.
A frontier model is overkill for extraction and small talk, and a cheap model fails hard reasoning. Picking one means either overpaying on easy prompts or underperforming on hard ones.
Paying frontier prices for easy work
A lot of real traffic — classification, extraction, short replies — is handled just as well by models that cost a fraction as much.
Routing rules that rot
Keyword and length rules are guesses. They break when prompts change and nobody can tell whether they're helping.
A new model every month
Every release means re-benchmarking and re-tuning. Most learned routers need retraining before they can use a new model.
Measured once. Routed forever. Always learning.
Connect your providers
Paste your API keys and pick models from each provider's live catalogue. Prices fill in automatically.
Every model gets a fingerprint
Each model answers a shared probe set once. Its strength on each task type becomes its fingerprint.
Each prompt is placed and predicted
Incoming prompts are matched to task types, and every model's quality is predicted — with an uncertainty range.
The best value wins, safely
Only models within your quality tolerance of the best are considered. The cheapest wins; weak answers are checked and escalated.
Watch the decision change.
Pick a kind of prompt and how much quality you'd trade for savings. Illustrative models and numbers — in production these come from your own models' fingerprints.
Everything a production router needs.
A quality guarantee, not a cost dial
You set the most quality you're willing to give up. Models outside that band are never chosen — even when they're cheaper. Hard prompts automatically tighten the band.
Zero-retrain onboarding
Add a model and it's fingerprinted once. No router retraining, ever.
Automatic pricing
Prices and context windows come from a live feed and refresh daily.
Answer checks
When a weaker model is chosen, a judge scores the answer and escalates if it falls short.
Learns from your traffic
Thumbs up/down and retries reshape each model's fingerprint for your prompts.
Drop-in OpenAI API
Chat completions, streaming, tools and JSON mode pass straight through. Change the base URL and key — nothing else.
Every decision explained
Each request records the candidates, their predicted quality and cost, and why the winner won — plus savings versus your strongest model.
Semantic cache
Repeated or near-identical prompts are answered instantly — no tokens, no credits.
Spend caps
Daily and monthly budgets per workspace and per key, with alerts before you hit them.
Evals & shadow tests
Score models on your own prompts, and try alternatives against live traffic safely.
PII redaction
Mask emails, cards, IDs and secrets before a prompt ever leaves for a provider.
Teams & roles
Invite colleagues as Owner, Developer or Viewer, enforced server-side.
Batch API
Up to 500 requests in one call, processed in the background at a reduced fee.
Better than one model. Safer than rules.
| One model for everything | Hand-written rules | LinuxAir | |
|---|---|---|---|
| Cost on easy prompts | Frontier price | Depends on the rules | Cheapest capable model |
| Quality on hard prompts | Good, if you pay for it | Often misrouted | Guarded by your tolerance |
| Adding a new model | Swap and hope | Rewrite rules | Probe once, done |
| Adapts to your prompts | No | No | Online learning |
| Explains each decision | — | Rule name | Quality, cost and reason |
| Provider outage | Requests fail | Manual fallback | Failover + circuit breaking |
| Repeated prompts | Paid for every time | Paid for every time | Served from cache, free |
| Cost control | Find out on the invoice | Find out on the invoice | Spend caps and alerts |
| Sensitive data | Sent as-is | Sent as-is | Redacted before sending |
Two lines to integrate.
Keep your OpenAI SDK. Point it at LinuxAir and use model="auto". The response tells you which model answered and why.
- Python, Node, cURL — any OpenAI-compatible client
- Streaming, tools and JSON mode supported
- Per-request control: tolerance, budget caps, model allow-lists
- Automatic failover to the next-best model on provider errors
from openai import OpenAI
client = OpenAI(
base_url="https://ai.linuxair.com/v1",
api_key="la-...",
)
r = client.chat.completions.create(
model="auto",
messages=[{"role": "user", "content": "Summarise this contract"}],
)
print(r.model) # the model LinuxAir choseimport OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://ai.linuxair.com/v1",
apiKey: process.env.LINUXAIR_KEY,
});
const r = await client.chat.completions.create({
model: "auto",
messages: [{ role: "user", content: "Summarise this contract" }],
});
console.log(r.model);curl https://ai.linuxair.com/v1/chat/completions \
-H "Authorization: Bearer $LINUXAIR_KEY" \
-H "Content-Type: application/json" \
-d '{"model": "auto", "messages": [{"role": "user", "content": "Hello"}]}'Questions, answered.
Do you mark up model usage?
Will routing make my answers worse?
How does it know which model is good at what?
What else does it do besides routing?
What if two models are equally good?
Can I self-host it?
Stop overpaying for easy prompts.
2,000 free credits on signup. Bring your own keys, change one base URL, and see the savings on your own traffic.