Instructions to use ApolloRaines/Pythia-1.4B-jBlaze-Reasoning with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use ApolloRaines/Pythia-1.4B-jBlaze-Reasoning with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="ApolloRaines/Pythia-1.4B-jBlaze-Reasoning")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("ApolloRaines/Pythia-1.4B-jBlaze-Reasoning")
model = AutoModelForCausalLM.from_pretrained("ApolloRaines/Pythia-1.4B-jBlaze-Reasoning", device_map="auto")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=40)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use ApolloRaines/Pythia-1.4B-jBlaze-Reasoning with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "ApolloRaines/Pythia-1.4B-jBlaze-Reasoning"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "ApolloRaines/Pythia-1.4B-jBlaze-Reasoning",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/ApolloRaines/Pythia-1.4B-jBlaze-Reasoning

SGLang

How to use ApolloRaines/Pythia-1.4B-jBlaze-Reasoning with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "ApolloRaines/Pythia-1.4B-jBlaze-Reasoning" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "ApolloRaines/Pythia-1.4B-jBlaze-Reasoning",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "ApolloRaines/Pythia-1.4B-jBlaze-Reasoning" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "ApolloRaines/Pythia-1.4B-jBlaze-Reasoning",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use ApolloRaines/Pythia-1.4B-jBlaze-Reasoning with Docker Model Runner:
```
docker model run hf.co/ApolloRaines/Pythia-1.4B-jBlaze-Reasoning
```

Pythia 1.4B -- jBlaze Reasoning Enhanced

A reasoning-enhanced version of EleutherAI's Pythia 1.4B, modified using jBlaze behavioral weight editing. No gradient-based training was performed. The model has the same parameter count as vanilla Pythia 1.4B. The only difference is targeted edits to weight matrices using jBlaze.

What changed

jBlaze applies behavioral modifications directly to model weight matrices. This produces targeted changes in the model's decision behavior without retraining. The reasoning-enhanced version applies two complementary behavioral modifications across all 24 transformer layers.

No fine-tuning. No LoRA. No gradient descent. No additional training data.

Benchmark results

Evaluated on a 100-question held-out reasoning benchmark across 5 categories. These questions were never used during the configuration search. Evaluation uses logit-level multiple-choice scoring (the same methodology as MMLU).

Model	Overall	Logic	Math	Sequences	Verbal	Causal	Perplexity
Raw Pythia 1.4B	11%	15%	10%	10%	10%	10%	--
DNP base (before reasoning edits)	7%	20%	10%	5%	0%	0%	2.64
jBlaze Reasoning	56%	55%	60%	30%	60%	75%	3.20

Overall held-out reasoning accuracy increased from 7% to 56% -- an 8x result, equivalent to a 700% relative increase in benchmark accuracy.

The gain is broad -- every category improved. Causal reasoning moved from 0% to 75%. Verbal reasoning from 0% to 60%. Math from 10% to 60%.

Perplexity increased from 2.64 to 3.20, indicating a modest distributional shift rather than catastrophic degradation.

Important context

This is a 1.4 billion parameter model. It does not produce high-quality free-form text regardless of reasoning edits. The improvement is measured at the logit/decision level, which is how standard benchmarks (MMLU, ARC, etc.) evaluate reasoning.
The benchmark contains 100 questions across 5 categories. Larger independent benchmarks would strengthen or weaken these results -- that is why we are publishing the model and evaluation script.
"8x higher accuracy on this benchmark" is accurate. "8x smarter" is not what we are claiming.
The base model was first processed with DNP (Direct Neural Programming) for knowledge injection before reasoning blazes were applied. The 7% baseline reflects the DNP model. Raw Pythia 1.4B scores 11% on the same benchmark -- both are near-random for reasoning.

Test it yourself

The evaluation script is included in this repository. Compare any model against this benchmark:

# Test the jBlaze reasoning-enhanced model
python eval_reasoning.py --model ApolloRaines/Pythia-1.4B-jBlaze-Reasoning

# Test vanilla Pythia 1.4B
python eval_reasoning.py --model EleutherAI/pythia-1.4b

# Test any other model
python eval_reasoning.py --model <your-model-path-or-hf-id>

Requirements: torch, transformers

How to use

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("ApolloRaines/Pythia-1.4B-jBlaze-Reasoning")
tokenizer = AutoTokenizer.from_pretrained("ApolloRaines/Pythia-1.4B-jBlaze-Reasoning")

What is jBlaze?

jBlaze is the behavioral weight editing compiler built by SAIQL. It applies targeted modifications to model weight matrices, changing specific behavioral traits without retraining.

The technology behind jBlaze is proprietary. The method is not published. The results are.

Released models: huggingface.co/ApolloRaines

Technical details

Base model: EleutherAI/pythia-1.4b (1.4B parameters, 24 layers, GPT-NeoX architecture)
Modification method: jBlaze weight editing (no gradients)
Parameter count: Unchanged (1,414,647,808)
Gradient-training data used: None
Compute cost: Under 2 minutes on an NVIDIA RTX 3090

Citation

@misc{raines2026jblaze-reasoning,
  title={jBlaze Reasoning Enhancement: Improving Held-Out Reasoning via Behavioral Weight Editing},
  author={Apollo Raines},
  year={2026},
  url={https://huggingface.co/ApolloRaines/Pythia-1.4B-jBlaze-Reasoning}
}

A Note on Our Released Models

Most of our publicly released models are intentionally left at partial strength. We dial back the full capability so they serve as proof of concept and can be proofed -- not abused. The point is to show what's possible, not to hand it out at full power. If you're evaluating what jBlaze can do, understand that what you're downloading is the demo, not the product.

Downloads last month: 1,356

Safetensors

Model size

1B params

Tensor type

BF16

Model tree for ApolloRaines/Pythia-1.4B-jBlaze-Reasoning

Base model

EleutherAI/pythia-1.4b

Finetuned

(76)

this model