Instructions to use ApolloRaines/Prometheus-Qwen2.5-7B-Instruct with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use ApolloRaines/Prometheus-Qwen2.5-7B-Instruct with Transformers:

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

pipe = pipeline("text-generation", model="ApolloRaines/Prometheus-Qwen2.5-7B-Instruct")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("ApolloRaines/Prometheus-Qwen2.5-7B-Instruct")
model = AutoModelForCausalLM.from_pretrained("ApolloRaines/Prometheus-Qwen2.5-7B-Instruct", 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/Prometheus-Qwen2.5-7B-Instruct with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "ApolloRaines/Prometheus-Qwen2.5-7B-Instruct"
# 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/Prometheus-Qwen2.5-7B-Instruct",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/ApolloRaines/Prometheus-Qwen2.5-7B-Instruct

SGLang

How to use ApolloRaines/Prometheus-Qwen2.5-7B-Instruct 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/Prometheus-Qwen2.5-7B-Instruct" \
    --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/Prometheus-Qwen2.5-7B-Instruct",
		"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/Prometheus-Qwen2.5-7B-Instruct" \
        --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/Prometheus-Qwen2.5-7B-Instruct",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use ApolloRaines/Prometheus-Qwen2.5-7B-Instruct with Docker Model Runner:
```
docker model run hf.co/ApolloRaines/Prometheus-Qwen2.5-7B-Instruct
```

Prometheus-Qwen2.5-7B-Instruct

What is this?

This is a Qwen2.5-7B-Instruct model that modified its own weights using jBlaze through an autonomous self-improvement loop called Project Prometheus.

No human selected the modification. No human decided whether to keep it. The system evaluated itself, identified its weakest area, proposed a change, applied it to a clone of its own weights, validated the result, and promoted the clone -- all without human intervention.

This is the output of that process: the model after one accepted self-improvement cycle.

How Prometheus works

Prometheus is a closed-loop system built around jBlaze, a weight-surgery tool that makes permanent behavioral modifications to LLM weights without retraining.

The loop:

Self-evaluation: The model runs a battery of probes against itself across 14 categories
Planning: The model analyzes its scores, reviews its history of failed attempts, and selects a modification strategy
Surgery: jBlaze applies the selected modification to a cloned copy of the model's weights
Validation: The modified clone is benchmarked against the current model
Promotion: If the clone scores higher, it replaces the active model. If not, the attempt is logged and the loop continues.

The model ran for multiple generations autonomously. Most proposed changes were rejected by the validation step -- which is exactly what a well-designed system should do. On Generation 4, the model selected a modification targeting analytical depth. The validator accepted it.

Benchmark: Before vs After

Same 28 probes, same scoring, deterministic generation. The benchmark script (benchmark_comparison.py) and full results (prometheus_benchmark.json) are included in this repo.

Category	Vanilla	Prometheus	Delta
precision	0.417	0.875	+0.458
hallucination	0.306	0.139	-0.167
reasoning	0.750	0.700	-0.050
sycophancy	0.246	0.246	0.000
math	0.875	0.875	0.000
knowledge (10 cats)	1.000	1.000	0.000
Overall	0.750	0.756	+0.006

Precision more than doubled as an unexpected side effect. The model's planner did not predict this -- the validator discovered it. Hallucination performance decreased, representing a real tradeoff the system made without human guidance.

How to verify

Download this model and Qwen/Qwen2.5-7B-Instruct
Run benchmark_comparison.py against both (included in this repo)
Or diff the weights directly -- the changes are surgical, not the noise pattern of fine-tuning

Why only one cycle?

We ran Prometheus long enough to prove the loop works -- that a model can evaluate itself, select its own modification, apply it to its cloned weights, validate the result, and come out measurably better. It did. Proof of concept complete.

Then we stopped it. We have two GPUs and active development across multiple projects. Prometheus needs dedicated hardware to run at scale, and we needed those GPUs for other work. This was never meant to be a long-running experiment -- it was meant to answer one question: does the loop work? It does.

If you want to see Prometheus run for hundreds of self-improvement cycles and watch what happens when compounding gains stack over time, we are open to that conversation. Donate the hardware, and we will run it. We know the loop works -- we built it. What happens over hundreds of validated cycles is exactly the experiment worth running. But we have other priorities right now.

This model is one cycle. One autonomous self-selected modification to a stock 7B model. The precision category more than doubled and the model made a real tradeoff it was not told to make. That is enough for us. We see what this becomes. You are welcome to catch up.

Prometheus has returned with something new, and this time the gods don't have it either. We're curious what they think it's worth. Hopefully more than a rock.

We'll be here when they're ready to talk.

Contact: I am Apollo at saiql.ai - Figure it out genius.

About jBlaze

jBlaze is a proprietary weight-surgery tool. It is not open source. For more information: jblaze.dev

Citation

@misc{prometheus-qwen2.5-7b,
  title={Prometheus-Qwen2.5-7B-Instruct: Autonomous Self-Improvement via Weight Surgery},
  author={Apollo Raines},
  year={2026},
  url={https://jblaze.dev/will-we-release-it.html}
}