Jasper-K-35B-MoE

Jasper-K-35B-MoE

Writes GPU kernels and improves their speed through repeated tries against a test environment. A mixture-of-experts model trained from Qwen3.6-35B-A3B with reinforcement learning, for engineers who tune GPU code.

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-35B-MoE is a Ragentile model that applies a mixture-of-experts design to GPU kernel tuning. The card says it comes from reinforcement learning post-training of Qwen3.6-35B-A3B. It writes candidate kernels, gets feedback on whether they compile, run correctly and run fast, and revises them over several turns.

Who it suits: GPU programmers and ML systems researchers who want a model that proposes faster kernel code, under the Apache 2.0 license.

Industry | Who uses it | How they use it | Example
AI infrastructure | GPU engineers | Draft and tune kernels for model workloads | Speed up a custom operator
Research | ML systems researchers | Study reinforcement learning on a mixture-of-experts base | Reproduce the kernel benchmark runs
High-performance computing | Performance engineers | Search for faster versions of existing kernels | Compare candidate kernels by measured time
Education | Students | Learn how feedback loops improve generated code | Watch a kernel improve over turns

Skip it if you do not write or tune GPU kernels, since the model is built for that one job.

Where to use it: It runs inside a runner that connects the model to a code evaluator.

• A serving setup you configure with the companion project on GitHub
• An execution environment that compiles, tests and times kernels
• Windows, macOS or Linux, with Python for the download

Use case | Who | What they get back
Kernel writing | GPU engineers | Candidate kernel implementations
Kernel tuning | Performance teams | Revised kernels after compile, correctness and timing feedback
Benchmark studies | Researchers | Speedup figures measured on a fixed protocol

How to set it up: You need Python, the weights, and the separate runner.

• Python with pip
• The companion GitHub project, which holds the inference runner, an evaluator template, sample feedback and a self-test
• A serving environment and an evaluator that you configure by its instructions

1. Install the Hugging Face hub tools with pip.
2. Download the model files into a local folder.
3. Get the runner from its GitHub project.
4. Set the model path, serving environment and evaluator as its instructions say.

python3 -m pip install --upgrade huggingface_hub
hf download ragentile/Jasper-K-35B-MoE --local-dir ./Jasper-K-35B-MoE

How to use it: You use the model through the runner. It sends a kernel task, runs the code the model writes, returns compile, correctness and timing feedback, and lets the model revise. The card points to the runner instructions for the exact steps.

Example: You give the runner a kernel task from your own workload. The model proposes an implementation, 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 to this, know that the model does not run alone. Download the weights, then read the runner instructions before you try a first task. Check the file size too. Hugging Face lists only about 10 MB of weights and 5.2M parameters for this repository, which does not match a 35B model, so confirm what the files hold.

If you know the field, the training used multi-rollout, multi-turn GRPO. Rewards based on improvement push the model to keep searching after it finds a correct kernel. Training used 180 KernelBenchFixed tasks at Level 1 and Level 2, with 20 more for monitoring. LeetCuda, a 50-task in-house set, was held out for testing.

Get a kernel task
Model writes a candidate kernel
Evaluator compiles, checks and times it
Feedback goes back to the model
Model revises over several turns

Good to know: The card reports the geometric mean of the best speedup per task, picked from 16 tries of up to four turns each. These figures come from the maker's own technical blog.

• License: Apache 2.0, with base-model attribution in the NOTICE file
• Cost to run: none named, apart from your own GPU hardware
• Data it reaches: the model files, the kernel code it writes and whatever your evaluator environment runs
• Not for: work outside GPU kernel optimization, which is the only use the card describes

On Hugging Face, 13 November 2026

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

Links

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

Get the model

Download its files with Hugging Face's command line:

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

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