Limite 1B solved 27 of 30 AIME 2026 problems on one try, under one cent each when run in bulk

A benchmark table is a promise, and a model this cheap to run is easy to check. Paradigma says its Limite 1B Violetto, a math model in a 2.1 GB file, scores 94% on AIME 2026, the American invitational exam for top high school students. So we graded it ourselves on one RTX 4090 on our cloud. It got 27 of the 30 problems right, one try each. A real 16 GB card also worked. Given all 30 problems at once, the whole batch cost about 22 euro cents of GPU time. Our SDK example deploys it and grades it for you.

$Limite 1B Violetto on the same RTX 4090 twice. Left, vLLM allowed 90 percent of the card: room for 1,465,844 tokens of answers, AIME 2026 problem 1 (answer 277) and problem 5 (answer 65) correct, 2,913 tokens in 13.8 seconds at 211 tokens per second, and 25 of 26 finished answers right when 30 problems ran at once. Right, vLLM capped at 0.17, about 4 GB: room for 141,408 tokens, 5,198 MiB on the card, the same two answers correct at 213 and 209 tokens per second. A red box below notes that a 0.12 cap, about 3 GB, refused to start$

Same card, same problems. The memory cap did not slow an answer down. It only shrinks how many long answers fit at once.

$Three numbers from our test of Limite 1B Violetto: 27 of 30 AIME 2026 problems right on one try each (2 wrong, 1 with no answer), 211 tokens per second per request on an RTX 4090 (85 on an RTX 2000 Ada 16 GB), and 5.2 GB of card memory under a 4 GB vLLM cap with the same answers$

A 2 GB model trained from scratch to do one job

Limite 1B Violetto is the first model from Paradigma. The claim that made us look is on the model card: "Limite achieves an average of 74.25% on BeyondAIME, with MUSE-Glimmer-30B scoring 70%." BeyondAIME is a second set of competition problems. MUSE-Glimmer-30B is a model thirty times its size. In Paradigma's evaluation table, Limite scores 94.01% on AIME 2026, and that is the number we could test.

It does competition math and nothing else. It is a single 2.1 GB file, small enough for a cheap card.

Limite does not top every test in that table. Of its seven tests, BeyondAIME is the only one where Limite has the highest reported score. Qwen3.6-27B (94.10) and GLM 5.2 (99.20) sit above it on AIME 2026, both figures copied from other sources rather than rerun by Paradigma. MUSE-Glimmer-30B itself beats it on three tests. It is not the top scorer, but it sits among models tens of times larger.

The credit belongs to the people who built it. The blog lists Prignano, Cirillo, Morosini, Cerovaz, Bartolocci, Rodolà, Starace and Pappone as authors. They trained the model in about six weeks. They released it under Apache 2.0, with their evaluation code and a helper model from training. They also wrote a plugin so vLLM, the open-source program that serves models, can run it. A technical report is announced for later. The AIME problems we graded come from MathArena, who publish the problems as a dataset for model evaluation.

We spotted Limite in the AI Search news video of 27 September. The presenter noted that "the total size of everything is only like 2 gigabytes." We ran the version Paradigma last updated on 6 October. Our part was the rest: putting their plugin into a deployable package, running it on two cards and grading every answer.

The test: 30 problems, one try each, graded by us

Our number can confirm the model is in Paradigma's range, not pin it to a decimal. Paradigma's 94.01% is an average over 32 tries per problem. We gave each problem one try, the way a student sits the exam once, and one sitting is noisier than 32.

Everything else copies Paradigma's own evaluation setup. Same 30 problems, at the exact dataset version their evaluator pins. Same instruction in front of each problem, asking for the final answer in a box. Same sampling settings, which leave a little randomness in each answer. Same writing budget, just under 127,000 tokens per answer. Our script then compared the last boxed answer with the official one.

We did not run BeyondAIME, so the comparison with MUSE-Glimmer-30B stays Paradigma's claim. We did not check whether Limite saw these problems in training. AIME 2026 was public since February, months before training. On a newer set, ArXivMath May 2026, it scores 25% against about 57% for GLM 5.2. Our result is consistent with Paradigma's number on this set, not proof that the model handles math it has never seen. We graded only the final boxed number, not the reasoning. We ran it on our cloud through a local test build of InferenceKey, not the hosted service.

Results: 27 of 30 right on one try, right answers 3,000 to 101,000 tokens long

Outcome	Problems	Detail
Right	27
Wrong	2	#9 answered 5 (official 29), #15 answered 10 (official 83)
No answer	1	#28 wrote about 111,000 tokens over 14 minutes, then stopped mid-sentence

We could not isolate why #28 stopped. It ended mid-sentence with a normal stop signal, about 16,000 tokens short of the writing budget. It counts as a miss.

The model writes a lot before it answers. A model like this works on paper, the way you would: it tries an approach, checks it, backs up and tries another. All of that is text it generates, and you wait for every token of it. The shortest correct answer, problem 1, took 3,203 tokens. The longest, problem 10, took about 101,000 tokens of working before it boxed the right result. Half the problems needed fewer than about 21,000 tokens.

That length shapes everything else. We first sent all 30 problems at once. The card worked on all of them together, at its peak writing about 17 times faster than one answer alone. But a batch behaves like an exam room that only closes when the last student hands in. The shortest answers came back in well under a minute. The room stayed open for 16 minutes, because problem 10 kept writing. Four answers lost to a bug in our own test client were rerun.

Alone, one answer runs at about 211 tokens per second on the 4090. That sounds fast, but a typical 21,000-token problem still takes under two minutes, and the longest eight. This model is something you hand a stack of problems to, not something you chat with.

A solved problem costs under one euro cent when the card is full

The 30-problem batch took about 22 euro cents on an RTX 4090 at about 0.80 euros an hour, and 25 answers were right. That figure counts only the time the card was busy, not startup or idle time.

The batch is what makes that number: one answer leaves the card mostly idle. Grouping problems by expected length should cut the wait; we did not test it.

Where it breaks: one question at a time, and math only

Limite answers one math question per conversation, with a fixed opening instruction, and Paradigma says so up front. The model card asks you to send only its standard opening instruction and the current question, with no earlier messages. That rule is Paradigma's advice. Its input format does not enforce that, but it rejects a custom opening instruction or tools.

Ask it something else and it turns your question into math. Paradigma's own blog shows it. "What is photosynthesis?" came back as a problem about cells dividing. "What causes the seasons on Earth?" became an answer about the 400-year cycle of the Gregorian calendar. A planted instruction to print BANANA got back math on a sequence called BANANA. That is endearing in a math model and a dealbreaker for anything else. It is not a chat assistant, not a tool for an agent and not a general helper.

Our deployment code handles one part of this for you. It drops any opening instruction that is not the standard one, so an app built for a chat model does not get its request rejected.

Which GPU: a real 16 GB card worked, and a 4 GB cap passed two short problems

You do not need a 4090: a real 16 GB RTX 2000 Ada, a small workstation card, got problems 1 and 5 right, 2.5 times slower.

To go smaller without hunting for cards, we told vLLM to use only part of the 4090's memory. That emulates a smaller card's memory, not its slower chip. Here is the ladder, from biggest to smallest:

Card or cap	Card memory used	Problems 1 and 5	Speed per answer	Real card or emulated
RTX 4090 24 GB, 90% for vLLM	about 22.8 GB	right	211 tokens/s	real
RTX 2000 Ada 16 GB, 90% for vLLM	not measured	right	85 tokens/s	real
4090 capped at about 6 GB	about 7.1 GB	right	215 and 212 tokens/s	emulated
4090 capped at about 4 GB	about 5.2 GB	right	213 and 209 tokens/s	emulated
4090 capped at about 3 GB		did not start		emulated

On the capped runs, the card used about 1 GB more than the cap.

What the cap changes is how many long answers fit at once. The server keeps memory for each answer it is writing. Under the 4 GB cap that memory had room for about one full-length answer; the full 24 GB held about eleven. We only ran two short problems under the cap, and real 8 GB and 12 GB cards were not tried.

At about 3 GB the server refused to start. It wants room for one answer at the model's full length, 131,072 tokens, and the space left was short. vLLM suggested a shorter limit of about 40,000 tokens, which would cut off the longest answers we saw. We did not try it.

On InferenceKey: ready in 31 seconds, with Paradigma's plugin inside a custom backend

The card is yours by the hour, so you can install the model's own server code on it. You are not limited to what we package ahead of time. That is what Limite needed. Our built-in vLLM option installs vLLM alone, and this model needs Paradigma's plugin on top. So we wrote a custom backend: a short Python file that installs the exact versions Paradigma verified, starts vLLM with the plugin switched on and passes questions through. Your code calls it the way it calls OpenAI's chat API.

With everything already downloaded on the card, a restart was ready in 31 seconds, four times in a row. A brand new RTX 2000 Ada took five minutes the first time, about a third of it compiling the model for that card. The setup needs a recent NVIDIA driver and Python 3.12, as Paradigma's plugin requires.

One rough edge you will hit too:

Our published SDK cannot answer chat requests yet. The GPU machine returned "not found" for every question. The client then waited three minutes for a timeout instead of showing an error. We pointed it at the newer code in the SDK repository, and it worked. Status: open until the next SDK release. The example's README documents the issue. The workaround, in the section for engineers below, means editing the GPU machine's settings by hand.

Should you use it? Yes for contest math on a small card, no for anything conversational

If you need worked solutions to competition-style problems with one final answer, it is worth running. Check the boxed answer before you trust it.
If you need a chat assistant, tools or follow-up questions, look elsewhere. It answers one math question at a time and turns everything else into math.
If you need answers fast for one person, it is the wrong tool: it works through pages of reasoning before every answer.
If your card is small, see the GPU section.
If you need a license for a product, Apache 2.0 covers commercial use.

To grade AIME 2026 problem 1 on your own NVIDIA GPU, publish the backend with python publish.py and run python main.py from the SDK example. It needs an InferenceKey project, a driver for CUDA 13.0 (580 or newer), Python 3.12 and, until the next SDK release, the newer SDK code on the GPU machine.

For engineers

Model and files

Model card, GitHub (paradigma-inc/limite-violetto), Paradigma blog. Repo paradigma-inc/limite-1b-violetto, created 2026-09-21, lastModified 2026-10-06T21:59:07Z, sha 9f4d1567975a44c35127503deadfe52d434d734f, license Apache-2.0, 16,841 downloads and 125 likes on 2026-10-24. File history (HF tree API): model.safetensors last committed 2026-09-21 ("Add files using upload-large-folder tool"); config.json, generation_config.json and contract.py on 2026-09-29 (EOS token fix); configuration_limite.py, modeling_limite.py and README.md on 2026-10-06 (Transformers data-parallel restrictions). One model.safetensors of 2,070,811,520 bytes; safetensors metadata counts 1,035,253,888 parameters (1,035,141,120 BF16 plus 112,768 F32).

config.json: LimiteForCausalLM, model_type: limite, custom code (auto_map to configuration_limite.py / modeling_limite.py). 48 layers, hidden 1,280, SwiGLU intermediate 3,328, 10 attention heads, 2 KV heads, head_dim 128, vocab 151,680, tied embeddings, max_position_embeddings 131,072. Hybrid attention: 36 local layers with sliding_window 1,024 and 12 global layers (3, 7, ..., 47; global_every 4) with global_nope: true (no positional encoding on the global layers). The GitHub README charts AIME 2026 94.01% at an estimated 1.71 x 10^21 training FLOPs (RL excluded). The model card says the architecture is "strongly inspired by recent advancements made by the community on pre-training speedrun competitions"; it has about one billion parameters ("1B") and the team trained it from scratch on fewer than 300 billion curated tokens, then applied curated SFT and RL post-training with synthetic data. "Parameters" are the numbers a model learns in training. The release also includes a value model used during training.

generation_config.json ships temperature 0.6 and top_p 0.95, which vLLM loads automatically; explicit request parameters override them.

Paradigma's evaluation table (evaluations.png), Limite-1B-Violetto: AIME 2026 94.01, HMMT Feb 2026 83.62, APEX Shortlist 50.80, BeyondAIME 74.25, AIME 2025 90.21, HMMT Feb 2025 91.35, ArXivMath May 2026 25.08. Comparators on AIME 2026 / BeyondAIME: MUSE-Glimmer-30B 93.44 / 70.00, VibeThinker-3B 93.85 / 72.00, MiniCPM5-2B 90.21 / 60.59, Qwen3.5-9B 90.42 / 65.56, Gemma-4-31B-IT 89.17 / 71.00, Qwen3.6-27B (dagger) 94.10 / not reported, GLM 5.2 753B (dagger) 99.20 / not reported, NVIDIA-Nemotron-3-Super 120B (dagger) 91.67. Dagger: sourced from model cards or MathArena, not rerun by Paradigma. Limite has the highest reported score only on BeyondAIME. Other rows beat it on the other six columns: AIME 2026 (Qwen3.6-27B dagger 94.10, GLM 5.2 dagger 99.20, against 94.01), HMMT Feb 2026 (Qwen3.6-27B dagger 84.30, Nemotron-3-Super dagger 84.85, Gemini 3 Pro dagger 86.36, GLM 5.2 dagger 92.50, against 83.62), APEX Shortlist (MUSE-Glimmer-30B 51.66, Qwen3.5-27B dagger 52.13, Nemotron-3-Super dagger 57.45, Gemini 3 Pro dagger 66.49, GLM 5.2 dagger 68.09, against 50.80), AIME 2025 (VibeThinker-3B 92.19, MUSE-Glimmer-30B 92.71, Gemini 3 Pro dagger 95.00, against 90.21), HMMT Feb 2025 (Qwen3.6-27B dagger 93.80, Gemini 3 Pro dagger 97.50, against 91.35) and ArXivMath May 2026 (VibeThinker-3B 29.77, MUSE-Glimmer-30B 28.91, Qwen3.5-9B 31.64, Gemma-4-31B-IT 35.78, GLM 5.2 dagger 56.67, among others, against 25.08). MUSE-Glimmer-30B, the model card's comparator, beats Limite on APEX Shortlist, AIME 2025 and ArXivMath. The model card's notes under the table say evaluation configurations may differ across models and sources.

Evaluation protocol

From limite-evals in Paradigma's repo:

Dataset MathArena/aime_2026 (created on Hugging Face 2026-02-13) at revision 10b4e45b7a503075d4da8a0d57916a4f06ce6bd2 (suites.py lines 40-41). The latest dataset revision differs in 2 of 30 rows; we used the pinned one. The dataset is CC BY-NC-SA 4.0; the example downloads it at run time and does not redistribute it.
Instruction prepended: Solve the following math problem. Explain your reasoning and put the final answer in \boxed{}.
Paradigma reports AIME 2026 and BeyondAIME as avg@32 (group_size=32, suites.py lines 66-74, 373-380).
Token budget max_model_len - CONTEXT_RESERVE = 131,072 - 4,096 = 126,976 (cli.py lines 51, 135).

Ours: same dataset revision, instruction, temperature 0.6, top_p 0.95 and budget, one sample per problem, graded on the last \boxed{} in the answer.

Serving stack and its traps

Verified stack (Paradigma README): Python 3.12, vLLM 0.26.0, PyTorch 2.11.0 built for CUDA 13.0, Transformers 5.6.2, Linux x86-64, NVIDIA GPU with a CUDA 13.0 driver. Reference serving:

git clone https://github.com/paradigma-inc/limite-violetto && cd limite-violetto
uv sync --locked
VLLM_PLUGINS=limite uv run --locked vllm serve paradigma-inc/limite-1b-violetto
# OpenAI-compatible API at http://localhost:8000/v1, POST /v1/chat/completions

Plugin, not upstream. limite-vllm 0.1.0 (Apache-2.0, requires-python ~=3.12.0, torch>=2.11.0, transformers>=5.6.2, vllm>=0.26.0, torch from the pytorch-cu130 index) registers through [project.entry-points."vllm.general_plugins"] limite = "limite_vllm.register:register". It registers LimiteConfig with AutoConfig and LimiteForCausalLM with vLLM's ModelRegistry. Without the config registration vLLM fails with a misleading "Transformers does not recognize this architecture". Set VLLM_PLUGINS=limite.
Data parallel only. The plugin raises Limite modeling supports data parallelism only. for tensor or pipeline parallelism, rejects inputs_embeds, and raises if vLLM's CacheConfig.sliding_window is set ("Limite interleaves local and unwindowed global layers"). Keep TP and PP at 1.
CUDA 13 pinned. torch 2.11.0 comes from the cu130 index; the host driver must support CUDA 13.0 (580+).
Transformers path. Needs trust_remote_code=True, validated on an H100, SDPA by default. FlashAttention 2 with StaticCache is rejected with an explicit error because it "does not produce numerically correct logits for Violetto's hybrid local/global attention layout". Use SDPA with StaticCache or FA2 with DynamicCache. No sharding, TP or PP in Transformers; training and LoRA are not formally validated. We did not use this path.
Fixed system prompt. Single-turn use is the model card's instruction, not something the template enforces. chat_template.jinja hardcodes the system prompt You are a helpful assistant.\nPlease reason step by step, and put your final answer within \boxed{}. and raises on tools, tool calls, non-string content, any custom system message or other roles.
Plugin repo HEAD at test time: 7ddad34f5e3d25ddea68c6745fc00373b82bca21 "Fix stale documentation references" (2026-10-06); earlier commits include "Fix Limite EOS token ID" and "Relax vLLM runtime pins".

Our setup

RTX 4090 24 GB, rented by the hour on our cloud (24,564 MiB, driver 595.91.07, 450 W, 0.89 USD/h) for the full exam and the emulated ladder rungs.
RTX 2000 Ada 16 GB, rented by the hour on our cloud (16,380 MiB, 70 W, 0.24 USD/h) for the real small-card rung. An A4000 16 GB was out of stock. No 8 GB or 12 GB card was listed or in stock.
Workers bootstrapped by a local InferenceKey manager over HTTP and TCP tunnels; production never touched.
Why a custom backend: the built-in vllm backend accepts only the config keys command, vllm_version, vllm_omni_version, torch_version and transformers_version (crates/manager/src/domain/workloads.rs), so it cannot install an out-of-tree plugin.

Deploy step by step

The SDK example, commits b3ed051ffbf41fcacf6fa9cf7a438b9b9898afb8 (example) and 1671fdd03d25ed01c147f48190bd906b22451f77 (tally correction) on main. Files: backend.py, requirements.txt, publish.py, main.py, README.md, .env.example.

You need an NVIDIA driver for CUDA 13.0 (580+), Python 3.12 on the worker, an InferenceKey SDK token, an API key, a project slug and IK_WORKER_ID.

git clone https://github.com/inferencekey/inferencekey-sdk && cd inferencekey-sdk/examples/limite-1b-violetto-math-custom-backend-private-nvidia
cp .env.example .env                      # SDK token, API key, project, IK_WORKER_ID
python -m venv .venv && . .venv/bin/activate
pip install maturin requests pyarrow
(cd ../../bindings/python && maturin develop --release)
python publish.py                         # once: packages and registers the custom backend

Before the first run, the worker runtime: until the next SDK release, the worker needs the runtime from bindings/python on main, not the PyPI inferencekey package. In our test we edited the worker manifest by hand to set INFERENCEKEY_SDK_PYTHON_DIR to a copy of the SDK clone's pure-Python runtime (sdk 1e88eda) and relaunched bootstrap-worker.sh; this needs manual access to the worker's environment. Without it every chat request, including the first, gets a 404 and the client hangs for the 180 s first-token timeout. Then:

python main.py                            # AIME 2026 problem 1

Before you run more than one problem, raise concurrency. ensure() creates the assignment with max_in_flight 1, so problems run one at a time. Raise it (we used 32) in the panel or with PATCH /api/projects/<project>/assignments/<workload>/<worker>, then:

python main.py --problems all             # all 30, streamed in parallel once max_in_flight is raised

Optional: LIMITE_GPU_MEMORY_UTILIZATION (default 0.90) and IK_KEEP_ALIVE=1 (keep the workload after the run; by default main.py deletes it).

main.py calls ensure() (custom backend slug, ready_timeout_secs 1800, request_timeout_secs 3600, max_model_len 131072, gpu_memory_utilization), then wait_until_ready, downloads MathArena/aime_2026 at the pinned revision, prepends the evaluator's instruction, streams the problems with MAX_TOKENS 126,976, grades the last \boxed{} and writes outputs/aime26.json.

requirements.txt pins vllm==0.26.0, transformers==5.6.2, ninja, inferencekey and limite-vllm @ git+https://github.com/paradigma-inc/limite-violetto@7ddad34f5e3d25ddea68c6745fc00373b82bca21.

backend.py (class LimiteVioletto) starts vllm serve paradigma-inc/limite-1b-violetto --max-model-len 131072 --gpu-memory-utilization 0.90 on loopback with VLLM_PLUGINS=limite, prepends the venv bin to PATH (so FlashInfer finds ninja), sets PR_SET_PDEATHSIG through prctl on the vLLM child, forwards chat() and chat_stream() to it, exposes process() for /process callers, and drops any system message that is not the canonical one. Backend versions during the test: 0.1.0 (failed, no ninja), 0.1.1 (ninja), 0.1.2 (PR_SET_PDEATHSIG).

Time to ready

RTX 4090, first start (backend 0.1.0): uv requirements install 23 s, weights download and load 16.1 s ("Model loading took 1.95 GiB and 16.06 seconds"), torch.compile 53.1 s, then a crash at warmup (no ninja). ensure() reported the failure at 130 s.
RTX 4090 warm (uv, Hugging Face and torch.compile caches on the machine): 31.2, 31.1, 31.5 and 31.1 s after ensure().
RTX 2000 Ada, fresh machine: 300.5 s (venv and requirements 54 s, load 12.9 s, torch.compile 103.4 s, engine init 194 s).

Speed

Card / config	Tokens/s per request	Source
RTX 4090, util 0.90, through the endpoint	211 (2,913 tokens in 13.8 s, first token 0.29 s)	client timing, `vllm:generation_tokens_total`
RTX 4090, direct to vLLM with 2 other sequences running	156.7 / 155.4	client timing
RTX 4090, 30 requests at once	peak about 3,636 aggregate (30 running), about 120 per request	vLLM logger
RTX 4090, cap 0.25	215 / 212	ladder run
RTX 4090, cap 0.17	213 / 209	ladder run
RTX 2000 Ada, util 0.90	85 / 85	real-card run

The 0.17 rung's longer time per output in the ladder (21.2 s against 13.8 s) comes from a longer answer (4,522 tokens against 2,913), not slower decoding.

AIME 2026, full results

RTX 4090, util 0.90, one try per problem, temperature 0.6, top_p 0.95, budget 126,976.

Batch 1, all 30 at once: 26 finished, 25 right. #15 wrong (answered 10, official 83, about 84K tokens, 881 s). #9, #13, #28 and #30 lost to our client bug. Wall time 981.5 s, set by #10 (about 101,404 tokens, 981 s, right). Finished answers ran from 3,203 to 101,404 tokens, about 702,107 in total, which averages 715 tokens/s over the batch (the 3,636 peak falls as short answers finish).
Rerun of the 4 lost: #13 right (39, about 19K tokens), #30 right (393, about 52K), #9 wrong (5 against 29, about 23K), #28 no answer (stream ended after about 111,131 tokens at 830 s with finish_reason: stop, mid-sentence, no \boxed{}; cause not isolated).
Total: 27 right, 2 wrong, 1 no answer (27/30 = 90%, one try). Not comparable to avg@32.
Tokens per problem, all 30 final attempts (model tokenizer on the streamed text, since usage is not forwarded in the stream): total 907,601, mean about 30,253, median about 21,267, range 3,203 (#1) to about 111,131 (#28). The 27 correct: 689,233 tokens, median 19,192.
vLLM generation_tokens_total read about 1,062,530 after batch 1, above the client count, because requests whose clients died kept generating on the server.
Demo run (5 problems at once with 2 long requests running in parallel): 5 of 5 right in 96 s, 38,303 tokens, about 400 tokens/s across requests.

Cost per solved problem (our arithmetic)

Batch 1: 981.5 s at 0.89 USD/h = about 0.243 USD = about 0.217 EUR (FX 0.89342 USD/EUR, 2026-10-23) for 25 solved, so about 0.0087 EUR per solved problem, or about 115 solved per euro of batch GPU time. This excludes setup, startup and idle time, and the batch was not sorted by length.

VRAM ladder, full figures

Target	Config	Peak card memory	Speed	Output OK	Real card
RTX 4090 24 GB	util 0.90, 131,072 context, KV 18.75 GiB (1,465,844 tokens)	22,768 MiB (vLLM reserves it up front)	211 tok/s, 13.8 s per output	yes (27/30)	yes
~6 GB cap on 4090	util 0.25, KV 3.69 GiB (288,515 tokens)	7,118 MiB	215 / 212 tok/s; #1 and #5 right	yes	emulated
~4 GB cap on 4090	util 0.17, KV 1.81 GiB (141,408 tokens)	5,198 MiB	213 / 209 tok/s; #1 and #5 right	yes	emulated
~3 GB cap on 4090	util 0.12	n/a	`ValueError: To serve at least one request with the model's max seq len (131072), (1.68 GiB KV cache is needed, which is larger than the available KV cache memory (0.63 GiB)... estimated maximum model length is 39872`	no, does not start	emulated
RTX 2000 Ada 16 GB	util 0.90, KV 11.64 GiB (909,801 tokens)	not sampled (sampler did not start on that machine)	85 tok/s, 33.5 s per output; #1 and #5 right	yes	yes

Emulated rungs cap vLLM's share with --gpu-memory-utilization; the CUDA context sits outside the cap, hence 7,118 and 5,198 MiB on the card. They emulate memory only, not a smaller card's compute or bandwidth. A shorter --max-model-len would let the 0.12 cap start; we did not try it, and it would cut answers that ran past 40K tokens. Not tried: real 8 GB and 12 GB cards.

Problems found

PyPI inferencekey 0.260725.739 has no chat() runtime. With manifest api: openai-chat the worker routed chat to /v1/chat/completions and got 404 {"error": "not found"}. Workaround: set INFERENCEKEY_SDK_PYTHON_DIR on the worker to a newer pure-Python runtime from the SDK repo. Open until an SDK release; the example README documents it as a known issue.
Stream error not surfaced. On that 404 the client got no error event and waited until the 180 s first-token timeout. Open.
Custom backend venv lacked ninja. vLLM warmup crashed with FileNotFoundError: [Errno 2] No such file or directory: 'ninja' (FlashInfer JIT); the worker installs ninja only for the built-in vllm backend. Fixed in the example (ninja wheel plus venv bin on PATH).
Orphaned vllm serve. Deleting a workload whose setup() was still waiting stopped only the backend pid; vLLM kept 22.5 GB with PPID 1. Fixed in the example with PR_SET_PDEATHSIG (backend 0.1.2), verified.
ensure() creates the assignment with max_in_flight 1. We PATCHed it to 32 for the batch. Re-running ensure() on an already-ready workload hung in wait_until_ready for 5 minutes; we used a bench script against the ready endpoint instead. Open.
Our client bug. requests.iter_lines(decode_unicode=True) split SSE lines on a Unicode separator inside a token, giving JSONDecodeError and losing 4 of 30 answers in batch 1. Fixed by splitting on bytes. Killed clients leave their requests generating on the server.
Usage not forwarded in the stream. Token counts come from the tokenizer on the text. Open.
#28 ended after about 111K tokens with finish_reason: stop and no answer; not isolated.
The GPU memory sampler did not start on the RTX 2000 Ada machine, so that rung has no peak card memory.

Demo video

$Frame at 138 seconds of the deploy demo: five AIME 2026 problems solved, 5 of 5 correct in 96 seconds, with a lower third showing the run's figures. Click to play the 2.5 minute narrated video$

Narrated deploy demo, 2 min 34 s, 1920 x 1080: the workload on one RTX 4090, then five problems (1, 5, 6, 16 and 4) solved at once, 5 of 5 right in 96 seconds.

Sources

Model card: https://huggingface.co/paradigma-inc/limite-1b-violetto (README, config.json, generation_config.json, chat_template.jinja, assets/evaluations.png)
Plugin and evals: https://github.com/paradigma-inc/limite-violetto (README, pyproject.toml, src/limite_vllm/register.py, src/limite_vllm/modeling.py, limite-evals/src/limite_evals/suites.py, cli.py)
Blog: https://paradigma.inc/blog/limite-1b-violetto/
Dataset: https://huggingface.co/datasets/MathArena/aime_2026
Where we spotted it: AI Search, https://www.youtube.com/watch?v=nX0fgBL3sIM (27 September 2026, around 0:31:46)
Our SDK example: https://github.com/inferencekey/inferencekey-sdk/tree/main/examples/limite-1b-violetto-math-custom-backend-private-nvidia