Jasper-K-27B

Jasper-K-27B

Reinforcement-learning tuned model for writing and speeding up GPU kernels, trained from a Qwen base with compile, correctness and timing feedback. For developers who work on GPU performance.

Made by ragentile 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: Jasper-K-27B comes from Ragentile and is built for GPU kernel optimization. The card says it is a 27B-parameter model made by reinforcement learning on top of a Qwen base, so it learns to write correct kernel code and then make it faster.

It learns by trial. The model proposes a kernel, gets feedback on compiling, correctness and measured speed, and revises over several turns. The card says rewards for improvement push it to keep searching for faster code after it already has a correct version.

Who it suits: It suits developers and researchers who write or tune GPU code and want a model trained on that exact job. It is not a general chat model.

Industry | Who uses it | How they use it | Example
Software | GPU engineers | Draft and tune kernels with a model | Speed up a matrix routine
AI infrastructure | ML engineers | Search for faster operators | Compare candidates by measured time
Research | RL researchers | Study multi-turn training with execution feedback | Reuse the described setup
Education | Students | See how a model improves code from feedback | Follow a compile and test loop

If you want a model for everyday chat or writing, you can skip it, since it is tuned for kernel work.

Where to use it: The card points to a separate inference project, which holds the run scripts, an evaluator template, feedback examples and a self-test. You configure your model path, serving setup and evaluator there.

• The separate inference project the card names
• A GPU environment that can compile and time kernels
• A local folder of downloaded weights

Use case | Who | What they get back
Kernel writing | GPU engineers | Candidate kernel code
Kernel tuning | ML engineers | Revised code after timing feedback
Benchmark study | Researchers | A model to test on kernel tasks

How to set it up: You need Python with pip to fetch the files. Hugging Face lists the weights at about 5 MB with 2.6M parameters, far less than a 27B model would need, so check the downloaded files before you plan your hardware.

• Python with pip
• The inference setup as its own project describes
• A GPU environment for compiling and timing kernels

1. Install the Hugging Face hub package.
2. Download the model files into a folder.
3. Set your model path in that project and start the evaluator.

pip install -U huggingface_hub
hf download ragentile/Jasper-K-27B --local-dir ./Jasper-K-27B

How to use it: You run the model through that project. It sends the model a kernel task, runs the code it writes, and returns compile, correctness and timing feedback for the next turn. The card gives no other run command.

Example: You give it a task to speed up an operation. The model writes a kernel, the evaluator reports whether it is correct and how fast it ran, and the model revises it over up to four turns.

For newcomers and experts: If you are new, read the technical blog the card links first, and try the self-test before real work. Expect to need GPU experience.

If you know the field, training used multi-rollout, multi-turn GRPO on 180 KernelBenchFixed Level 1 and 2 tasks, with 20 more kept for monitoring. LeetCuda, a set of 50 tasks, was held out for testing. The card reports a geometric mean speedup of 3.471x on KernelBench against 2.289x for the base model, and 2.580x against 2.161x on LeetCuda.

Model writes a candidate kernel
Evaluator compiles and checks it
Timing feedback comes back
Model revises over later turns

Good to know: The card says its scores use best speedup over 16 trajectories of up to four turns, and that the KernelBench set includes training tasks. The weights are under Apache 2.0, with base-model credit in a notice file.

• License: apache-2.0
• Cost to run: none named
• Data it reaches: files you download, and the code your evaluator runs
• Not for: general chat or tasks outside GPU kernel work

On Hugging Face, 13 November 2026

• Task: reinforcement learning
• Parameters: 2.6M
• Weights: about 5 MB in BF16; about 1 MB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 106
• Likes: 6
• License: apache-2.0
• Based on: Qwen/Qwen3.8-27B
• Quantized versions: 1
• Tags: safetensors, qwen3_5, kernel-optimization, reinforcement-learning

Links

• Model: https://huggingface.co/ragentile/Jasper-K-27B
• Files: https://huggingface.co/ragentile/Jasper-K-27B/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download ragentile/Jasper-K-27B

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