Unlimited tokens on a simple plan
Running a local model means always having to choose between quality and speed. Paying per token means there is a meter running the whole time you work. Cabrio gives you a reliable model, two guaranteed connections and unlimited tokens. No quota, no rate limiting, no context hacking.
Pre-registerNo payment now. We email you when the beta opens.
What you get
Two guaranteed connections
Two of your requests are always let onto the card, however busy it is. You are never turned away at the door.
The rest queue up
Past your two you use whatever is spare, at whatever speed it happens to be running. When there is nothing spare your request waits its turn instead of failing.
Unlimited tokens
No quota and no meter. We don't count what you send or what comes back, so there is nothing to run out of.
A model worth using
Full weights at 256K context, not a quant squeezed down until it fits. Qwen3.8-27B, or DeepSeek V4 Flash on the Flash plan.
Nobody reads it
Your prompts are never used for training and never read. Caching is keyed to your account, so nothing of yours is reused for anyone else.
Nothing to maintain
No drivers, no rebuilds, no waiting for someone to quant the model you wanted. Change a base URL in whatever you already use.
The trade-off triangle
Anyone running a model on their own card is juggling three things and can only ever have two of them.
Context
How much you can put in front of it before you have to start throwing things away.
Quality
Whether you run the real weights, or a quant squeezed down until it fits in the VRAM you own.
Speed
How fast the tokens actually come back once everything else is loaded.
Every setup on your own hardware lands somewhere inside it. Stretch the context and you drop to a smaller quant to pay for it. Keep the good weights and the context collapses. Get both and you start switching things off to claw the speed back. Which corner hurts most depends on the model and the card, but there is always a corner that hurts.
Cabrio serves models from high performance datacenter GPUs built for throughput and reliability.
What's the catch
Cabrio rents datacenter resources and pools requests through a proxy that decides what runs, what waits, and in what order.
Shared performance GPUs
We rent serving GPUs and share each one across a group of accounts. That is the whole economy of it: a card nobody would buy for themselves is straightforward to run once the cost is spread across the people using it.
Two guaranteed connections
Every account gets two connections at any time. The GPU is allocated as requests arrive, and those two are never overbooked, so they are there whenever you come to use them.
Unused resources are distributed
Most accounts sit idle most of the time. Whenever connections are free they go to serving requests from the queue, so spare capacity is never wasted and you regularly run more than two at once.
Fair use connection pooling
Concurrent requests beyond your two guaranteed connections are serviced from a queue. Whoever is using fewer tokens, with smaller requests, is served first, so one heavy job cannot hold the pool while everyone else waits behind it.
Privacy first caching
Every request is prefixed and keyed to your account, so cached state is never shared between accounts and nothing of yours can surface in anybody else's.
Two is the floor, not the ceiling. Most of the time the card has room and you run four or six at once without noticing. When it does not, the extra ones wait rather than fail. And when you stop, nothing sits reserved for you. The card gives your places to whoever is working.
Account A has been hammering the card, so it drops back. You have been quiet, so you go first and come round more often. Stop for a few minutes and your place at the front returns on its own. Nobody is blocked, nobody is billed extra, and heavy use costs you a little more waiting at busy times rather than a bill or a cut-off.
A request on a quiet card runs several times faster than the same request when the card is full. That is the trade you make by sharing one, and it is the reason the queue exists at all. We are re-measuring the exact figures against Qwen3.8-27B and will publish them here rather than estimate them.
So the catch, if you want to call it one: there is no token limit, but there is a rate. You cannot push through more than your connections can carry, and that is the whole of it.
Two capable models to choose from
Qwen3.8-27B
- Parameters
- 27B dense
- Input
- Text, image, video
- Best for
- Personal assistants, data, automation
- Terminal Bench 2.1
- 73.0
From Alibaba's Tongyi Lab, August 2026, open weights under Apache 2.0. It reads images and video as well as text, so a screenshot or a mockup goes straight into the prompt. 262K of context natively.
Its model card also reports 61.7 on SWE-bench Pro, 90.3 on LiveCodeBench v6 and 89.2 on GPQA Diamond.
DeepSeek V4 Flash
- Parameters
- 304B, MoE
- Input
- Text
- Best for
- Coding agents, reasoning tasks
- Terminal Bench 2.1
- 82.7
The 0731 checkpoint, open weights under MIT. A mixture of experts with a speculative decoding module attached, which is what lets something this size answer at a sensible speed.
Its card reports 54.4 on DeepSWE and 70.3 on Toolathlon-Verified, beats the far larger V4 Pro preview on every benchmark listed, and on DeepSeek's own table lands within a couple of points of Opus 4.8.
Terminal Bench 2.1 is on both model cards, so those two numbers are directly comparable: that gap is what you are paying the difference for. Both are served at 256K of context, which is Qwen3.8-27B natively and well inside what Flash will do.
What sharing a card does and does not mean
Requests run batched together, which is where the speed comes from. Batching does not mix them. Each request gets its own KV cache blocks and attends only to its own tokens, so nothing of yours can turn up in somebody else's output.
The part that genuinely can leak on a shared engine is the prefix cache. vLLM lets requests with identical prefixes reuse each other's cached blocks, and that is measurable from the outside: a suspiciously fast first token tells you somebody has already sent what you just sent. vLLM's answer is a per-request cache salt, folded into the hash of the first block so that only requests carrying the same salt can reuse each other's work. We set that salt to your account id on every request and overwrite whatever the client sent, so your cache is only ever reused by you.
vLLM's own documentation is blunt that it is not a multi-tenant system, and says to put it behind a proxy that exposes only the endpoints you actually need. That proxy is the thing we built. The engine is never reachable from outside, and the only endpoints you can touch are the completion ones.
None of this is a mechanism we invented. It is vLLM's, used the way vLLM says to use it. If the engine could not isolate this properly we would not claim to either.
Spend billions of them
There is no per-token price to model and no monthly allowance to ration. Nothing counts down, nothing resets on the first, and no dashboard tells you that you are at eighty percent on the nineteenth. Push billions of tokens through it and the bill is the same thirty dollars it was at the start of the month.
What limits you is the connection, and a connection does not run out.
Three plans
- Model
- DeepSeek V4 Flash
- Guaranteed
- 2 connections
- Context
- 256K
- Tokens
- Unlimited
Flat price, cancel whenever. No per-token charges and no overage bill. Fair use covers resale and scraping, not running agents all day.
Pre-register for the beta
Ask us something
If any of this is unclear, or you want to know whether it will work for what you are building, write and we will answer.