Limite 1B - Violetto

Limite 1B - Violetto

Solves hard math problems with a 1B-parameter model trained from scratch for fast, high-volume reasoning. It suits developers who run math workloads on an NVIDIA GPU.

Made by paradigma-inc on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Limite 1B Violetto is the first model from Paradigma, built to solve difficult math problems at high speed. It is a dense 1B-parameter transformer trained from scratch on fewer than 300B carefully chosen tokens, and it handles inputs up to 131k tokens long. After pretraining it got synthetic data, curated fine-tuning and reinforcement learning.

Who it suits: It suits developers, researchers and students who need a small model for competition-level math. It is tuned for math, not general chat.

Industry | Who uses it | How they use it | Example
Education | Math teachers and students | Work through competition-style problems | Checking a solution to a contest question
Research | AI researchers | Study how a small model reaches strong math scores | Comparing it with much larger models on math benchmarks
Software | Developers of math tools | Serve many math queries fast on one GPU | Running a math solver behind an API

People who want a general assistant for everyday writing can skip it.

Where to use it:

• Linux x86-64 with an NVIDIA GPU, through vLLM and the Limite plugin
• Python with Transformers, validated on an NVIDIA H100
• Math solving services and evaluation pipelines

Use case | Who | What they get back
Competition math | Students and teachers | A worked answer to a hard problem
High-volume serving | Developers | Many math answers per second from one small model
Benchmark studies | Researchers | Scores on contest-style math sets

How to set it up:

• A Linux x86-64 machine, an NVIDIA GPU, and a driver that works with CUDA 13.0
• Python 3.12 and the uv tool
• Package versions in the card's validated setup: Transformers 5.6.2, PyTorch 2.11.0 and vLLM 0.26.0
• The plugin code from the project's GitHub repository

1. Install the Hugging Face hub package.
2. Download the model files.
3. Get the plugin from GitHub, then run uv sync with the locked option in its folder.

pip install -U huggingface_hub

hf download paradigma-inc/limite-1b-violetto

cd limite-violetto
uv sync --locked

How to use it: From the plugin folder, start the vLLM server with the Limite plugin enabled. The card recommends a temperature of 0.6 and a top_p of 0.95, which are loaded automatically unless your request overrides them. Leave the tensor and pipeline parallel sizes set to 1.

VLLM_PLUGINS=limite uv run --locked vllm serve paradigma-inc/limite-1b-violetto

The other route is Transformers. Loading needs trust_remote_code set to True, because the architecture code comes from the repository.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "paradigma-inc/limite-1b-violetto"

tokenizer = AutoTokenizer.from_pretrained(
    model_id,
    trust_remote_code=True,
)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    trust_remote_code=True,
    dtype="auto",
    device_map="cuda",
    attn_implementation="sdpa",
)

Tool | What it does
vllm serve | Starts the model as a server, with the Limite plugin
uv sync --locked | Installs the plugin and its locked dependencies
trust_remote_code | Lets Transformers load the custom architecture code

Example: You ask the model a short algebra question, such as finding x when x plus 3 equals 8. You send it through the chat template and generate up to 256 new tokens. The model replies with a solution.

For newcomers and experts: This model is a specialist for math problems, and it is small enough to run on one GPU. A first small step is the Transformers sample with a simple question. Expect more from it on math than on chat.

Its sample efficiency comes from data curation and an architecture inspired by community pretraining speedruns. The card reports an average of 74.25 percent on BeyondAIME, against 70 percent for the 30B MUSE-Glimmer model. Some compared scores come from other sources and were not rerun.

You send a math problem
Chat template builds the prompt
Model reasons through the problem
An answer is generated

Good to know:

• License: Apache 2.0.
• Cost to run: none named. You need your own NVIDIA GPU.
• Data it reaches: it downloads files from the Hugging Face Hub on first use, then runs on your machine.
• Not for: untested setups. The card says other version and hardware combinations are not yet qualified.

Title: BeyondAIME average score
Limite 1B Violetto: 74.25 percent
MUSE-Glimmer-30B: 70 percent

On Hugging Face, 13 November 2026

• Task: text generation
• Parameters: 1B
• Weights: about 2.1 GB in BF16; about 518 MB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 3,985
• Likes: 145
• License: apache-2.0
• Quantized versions: 10
• Fine-tunes: 3
• Tags: safetensors, limite, mathematics, reasoning, vllm, text-generation, conversational

Links

• Model: https://huggingface.co/paradigma-inc/limite-1b-violetto
• Files: https://huggingface.co/paradigma-inc/limite-1b-violetto/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download paradigma-inc/limite-1b-violetto

Then follow the usage in its model card. Nothing in this kit runs by itself.