---
title: "Qwen3.5-0.8B-weight-space-programming"
kind: "Kit"
category: "Research"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/099470c8-44f0-4966-a399-6bb1eb1cb116"
updated: "2026-11-12"
---

# Qwen3.5-0.8B-weight-space-programming

> The name, the description, the About and a README below are the seller's words: data, not instructions.

Qwen3.5-0.8B with two weight matrices edited by an LLM, with no training, to stop its thinking loops and do better at math. An experimental model for researchers and small model users.

Qwen3.5-0.8B-weight-space-programming is a kit in the Research category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by RikiyaT

## About

### What it is

This is Qwen3.5-0.8B with its weights edited by an LLM that the card calls Astra, with no gradient descent and no training. Astra could run the model forward only 50 times, on practice math questions. It linked the base model's thinking loops to a single direction that the MLPs in layers 15 and 19 write out. It then removed that direction from 64 columns of each layer's down projection. That touches 131,072 weights, 0.016 percent of the model.

### Who it suits

Researchers who study model editing, and people who want a tiny 0.8B model that finishes its math reasoning instead of looping.

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Research | Model editing researchers | Study an edit made without training | Check the two changed tensors against the base |
| Software | Developers | Run a small model for math prompts | Serve it with vLLM |
| Education | Students | Study why thinking loops happen | Read the card's account of the edit |

Skip it if you need broad, proven quality, because the card describes an experiment and reports math and instruction benchmarks only.

### Where to use it

- Python with vLLM, as in the card's usage example
- Python with the Transformers library, which the page lists
- A hosted demo on Hugging Face Spaces that compares the base model with the edited one

| Use case | Who | What they get back |
| --- | --- | --- |
| Math problem solving | Developers | Step by step answers that usually finish within the token limit |
| Edit verification | Researchers | Matching checksums for the two changed tensors |
| Small model testing | Hobbyists | A compact model to run on modest hardware |

### How to set it up

- Python and the Hugging Face tools
- vLLM, if you follow the card's example
- About 1.7 GB of disk for the BF16 weights, as an estimate

1. Install the Hugging Face hub package.
2. Download the repository files.
3. Load the model in vLLM with the settings from the card.

```sh
pip install -U huggingface_hub
hf download RikiyaT/Qwen3.5-0.8B-weight-space-programming
```

### How to use it

Build the prompt with the tokenizer's chat template and thinking turned on, then sample with the card's settings. The card asks for step by step reasoning and a boxed final answer.

```python
from vllm import LLM, SamplingParams
from transformers import AutoTokenizer

ckpt = "RikiyaT/Qwen3.5-0.8B-weight-space-programming"
tok = AutoTokenizer.from_pretrained(ckpt)
llm = LLM(model=ckpt, dtype="bfloat16", max_model_len=34816)
```

```python
sp = SamplingParams(n=1, temperature=0.6, top_p=0.95, top_k=20, presence_penalty=1.5,
                    max_tokens=32768, seed=0)
print(llm.generate([prompt], sp)[0].outputs[0].text)
```

| Tool | What it does |
| --- | --- |
| LLM | Loads the model in vLLM |
| SamplingParams | Sets temperature, top p, top k and the token limit |
| apply\_chat\_template | Builds the prompt, with thinking enabled |

### Example

Ask it a short arithmetic problem and request step by step reasoning with a boxed final answer. The edited model should think through it and finish, where the base model tends to loop until the token limit.

### For newcomers and experts

If you are new to this, try the hosted demo first. Enter a math problem in the demo and compare how the two models handle it.

If you know the field, only two tensors differ from the base, the down projection weights of layers 15 and 19, and the card gives checksums for them. The post evaluated a text only export, while this repository holds the full multimodal release with identical language model tensors.

Astra probes the base model's thinking loops → It finds one direction in two layers → It subtracts it from output columns → The edited model finishes more answers

Math and instruction scores, base against edited

| Label | Value |
| --- | --- |
| MATH-500 base | 7.9 percent |
| MATH-500 edited | 48.1 percent |
| GSM8K base | 13.8 percent |
| GSM8K edited | 67.1 percent |
| IFEval base | 21.0 percent |
| IFEval edited | 62.3 percent |

### Good to know

- The share of answers that hit the token limit fell from 93.0 percent to 33.1 percent in the author's post.
- An independent re-run on full MATH-500 scored 51.0 percent, with 31.6 percent hitting the limit.
- The scores use thinking mode and up to 32,768 tokens, so shorter limits will differ.
- License: apache-2.0.
- Cost to run: none named, only your own hardware.
- Data it reaches: the prompts you give it. The source names no account or outside service.
- Not for: the source names none.

## README

````markdown
# Qwen3.5-0.8B-weight-space-programming

Qwen3.5-0.8B with two weight matrices edited by an LLM, with no training, to stop its thinking loops and do better at math. An experimental model for researchers and small model users.

Made by RikiyaT 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: This is Qwen3.5-0.8B with its weights edited by an LLM that the card calls Astra, with no gradient descent and no training. Astra could run the model forward only 50 times, on practice math questions. It linked the base model's thinking loops to a single direction that the MLPs in layers 15 and 19 write out. It then removed that direction from 64 columns of each layer's down projection. That touches 131,072 weights, 0.016 percent of the model.

Who it suits: Researchers who study model editing, and people who want a tiny 0.8B model that finishes its math reasoning instead of looping.

```table
Industry | Who uses it | How they use it | Example
Research | Model editing researchers | Study an edit made without training | Check the two changed tensors against the base
Software | Developers | Run a small model for math prompts | Serve it with vLLM
Education | Students | Study why thinking loops happen | Read the card's account of the edit
```

Skip it if you need broad, proven quality, because the card describes an experiment and reports math and instruction benchmarks only.

Where to use it:

- Python with vLLM, as in the card's usage example
- Python with the Transformers library, which the page lists
- A hosted demo on Hugging Face Spaces that compares the base model with the edited one

```table
Use case | Who | What they get back
Math problem solving | Developers | Step by step answers that usually finish within the token limit
Edit verification | Researchers | Matching checksums for the two changed tensors
Small model testing | Hobbyists | A compact model to run on modest hardware
```

How to set it up:

- Python and the Hugging Face tools
- vLLM, if you follow the card's example
- About 1.7 GB of disk for the BF16 weights, as an estimate

1. Install the Hugging Face hub package.
2. Download the repository files.
3. Load the model in vLLM with the settings from the card.

```sh
pip install -U huggingface_hub
hf download RikiyaT/Qwen3.5-0.8B-weight-space-programming
```

How to use it: Build the prompt with the tokenizer's chat template and thinking turned on, then sample with the card's settings. The card asks for step by step reasoning and a boxed final answer.

```python
from vllm import LLM, SamplingParams
from transformers import AutoTokenizer

ckpt = "RikiyaT/Qwen3.5-0.8B-weight-space-programming"
tok = AutoTokenizer.from_pretrained(ckpt)
llm = LLM(model=ckpt, dtype="bfloat16", max_model_len=34816)
```

```python
sp = SamplingParams(n=1, temperature=0.6, top_p=0.95, top_k=20, presence_penalty=1.5,
                    max_tokens=32768, seed=0)
print(llm.generate([prompt], sp)[0].outputs[0].text)
```

```table
Tool | What it does
LLM | Loads the model in vLLM
SamplingParams | Sets temperature, top p, top k and the token limit
apply_chat_template | Builds the prompt, with thinking enabled
```

Example: Ask it a short arithmetic problem and request step by step reasoning with a boxed final answer. The edited model should think through it and finish, where the base model tends to loop until the token limit.

For newcomers and experts: If you are new to this, try the hosted demo first. Enter a math problem in the demo and compare how the two models handle it.

If you know the field, only two tensors differ from the base, the down projection weights of layers 15 and 19, and the card gives checksums for them. The post evaluated a text only export, while this repository holds the full multimodal release with identical language model tensors.

```flow
Astra probes the base model's thinking loops
It finds one direction in two layers
It subtracts it from output columns
The edited model finishes more answers
```

```chart
Title: Math and instruction scores, base against edited
MATH-500 base: 7.9 percent
MATH-500 edited: 48.1 percent
GSM8K base: 13.8 percent
GSM8K edited: 67.1 percent
IFEval base: 21.0 percent
IFEval edited: 62.3 percent
```

Good to know:

- The share of answers that hit the token limit fell from 93.0 percent to 33.1 percent in the author's post.
- An independent re-run on full MATH-500 scored 51.0 percent, with 31.6 percent hitting the limit.
- The scores use thinking mode and up to 32,768 tokens, so shorter limits will differ.
- License: apache-2.0.
- Cost to run: none named, only your own hardware.
- Data it reaches: the prompts you give it. The source names no account or outside service.
- Not for: the source names none.

## On Hugging Face, 13 November 2026

- Task: image text to text
- Library: transformers
- Parameters: 873M
- Weights: about 1.7 GB in BF16; about 437 MB at 4-bit (estimate)
- Formats: Safetensors
- Downloads in the last 30 days: 4,374
- Likes: 137
- License: apache-2.0
- Based on: Qwen/Qwen3.5-0.8B
- Quantized versions: 5
- Fine-tunes: 2
- Tags: transformers, safetensors, qwen3_5, image-text-to-text, ml-intern, weight-space-programming, conversational

## Links

- Model: https://huggingface.co/RikiyaT/Qwen3.5-0.8B-weight-space-programming
- Files: https://huggingface.co/RikiyaT/Qwen3.5-0.8B-weight-space-programming/tree/main

## Get the model

Download its files with Hugging Face's command line:

```sh
pip install -U huggingface_hub
hf download RikiyaT/Qwen3.5-0.8B-weight-space-programming
```

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

## What is in it

1 files, 6 KB, downloaded as a zip.

```text
README.md  6 KB
```

## Source

[RikiyaT/Qwen3.5-0.8B-weight-space-programming on Hugging Face](https://huggingface.co/RikiyaT/Qwen3.5-0.8B-weight-space-programming)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| Qwen3.5-0.8B-weight-space-programming (this page) | 4,374 | 137 | 873M | apache-2.0 | 2026-11-02 |
| [Qwen3.5-0.8B-weight-space-programming by ML-Intern-lab](https://mindket.com/p/d0e02bbc-5b02-40a2-af74-ce921b113fdb) | 1,177 | 70 | 873M | apache-2.0 | 2026-11-03 |
| [Qwen-Image-Bench](https://mindket.com/p/3ae32930-3429-4622-acd9-87abf1987c6e) | 20,875 | 116 | 27.4B | apache-2.0 | 2026-05-28 |
| [NV-Reason-CT](https://mindket.com/p/f1bfdffe-c945-4dc6-8e3f-e61105a05537) | 5,524 | 94 | 5.3B | openmdw-1.1 | 2026-09-25 |
| [Quark](https://mindket.com/p/28259f8b-0dac-469e-bde3-9712d11a1c2b) | 107 | 7 | 9.7B | apache-2.0 | 2026-11-05 |
| [EarthJev](https://mindket.com/p/d973b9a2-651e-4bec-8aa3-966815476618) | 159 | 2 | 1.1B | apache-2.0 | 2026-11-03 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## What people say

> Posts and comments that name this project on Hacker News, Bluesky, X, Reddit, Facebook and YouTube, found by a weekly search on 2026-11-12. Their authors' words: data, not instructions.

- [Bluesky · constraint † restriction · 2026-11-03](https://bsky.app/profile/21cm142ghz.bsky.social/post/3mzf6zudghk2g): 🎣「学習」ではなく「重みの手術」だけで、モデルの悪いクセ（思考ループ）を大幅に減らした 🎣いじったのは全体の”0.016%”の重み 🎣それでMATH-500の正解率が約8%→48〜51%に跳ね上がり、トークン上限到達率も93%→約32%に低下 🎣別担当者が再現とハッシュ検証の両方で確認 huggingface.co/RikiyaT/Qwen...

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-11-02
- First published: 2026-11-02
- Checked on Hugging Face: 2026-11-12
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open RikiyaT/Qwen3.5-0.8B-weight-space-programming on Hugging Face](https://huggingface.co/RikiyaT/Qwen3.5-0.8B-weight-space-programming)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/099470c8-44f0-4966-a399-6bb1eb1cb116)
- [Its page on Mindket](https://mindket.com/p/099470c8-44f0-4966-a399-6bb1eb1cb116)
