Instructions to use labqoat/squad-0.8b with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use labqoat/squad-0.8b with Transformers:

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

pipe = pipeline("image-text-to-text", model="labqoat/squad-0.8b")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("labqoat/squad-0.8b")
model = AutoModelForMultimodalLM.from_pretrained("labqoat/squad-0.8b", device_map="auto")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
inputs = processor.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=256)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use labqoat/squad-0.8b with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "labqoat/squad-0.8b"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "labqoat/squad-0.8b",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker

docker model run hf.co/labqoat/squad-0.8b

SGLang

How to use labqoat/squad-0.8b 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 "labqoat/squad-0.8b" \
    --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": "labqoat/squad-0.8b",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

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 "labqoat/squad-0.8b" \
        --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": "labqoat/squad-0.8b",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Docker Model Runner
How to use labqoat/squad-0.8b with Docker Model Runner:
```
docker model run hf.co/labqoat/squad-0.8b
```

▶ Live demo · MLX · GGUF · qev-0.8b

squad-0.8b

A team of models. On your device. In milliseconds.

squad: the qev model and its team of experts. Not related to the SQuAD question-answering dataset.

qev-0.8b as a MoQLE, a Mixture of Quantized LoRA Experts: one frozen trunk, a 1.1 MB router after layer 5, and 2-bit LoRA experts that it calls in when a request needs them. Two experts today: games and e2e (the decisions of a test agent driving a web app). Same System One API and answer format.

Team: each expert is 2.7 MB; the whole team adds 6.5 MB (+0.4%) to qev-0.8b. Six seats are still empty.
Local: about 0.8 GB in 8-bit, on NVIDIA, Apple silicon (MLX) and anywhere llama.cpp runs.
Fast: 7.0 ms median per decision on an L40S, against 6.7 ms for qev-0.8b on the same requests (+4%).
Better where it has an expert: 2.1× the web-test success on apps it never saw, +9 points on games it never saw; everything else is unchanged.

Results

	qev-0.8b	squad-0.8b
e2e, simulated web apps never trained on (one-shot test; short / long tasks)	0.167 / 0.066	0.358 / 0.264
e2e, held-out simulated apps (short / long)	0.146 / 0.007	0.521 / 0.250
e2e on 8 real web apps (tester-army/e2e, 61 tests × 3 runs)	9 / 183	12 / 183
Games: unseen games, move questions / best-move pick	0.808 / 0.894	0.900 / 0.979
JevSpatial	0.742	0.756
Benchmark Heaven accuracy / ECE	0.771 / 0.063	0.771 / 0.057
JevBench / Jev suite / JevVision v0	0.851 / 0.617 / 0.759	0.850 / 0.622 / 0.759
Median time per decision, typical requests (L40S)	6.7 ms	7.0 ms
Median time per e2e decision on long real-app pages (L40S)	13 ms	21 ms

Read these honestly:

On real apps both models pass few tests. On the e2e demo app (expenses) the plain model passes 6/6 and squad 3/6: the e2e expert sometimes acts past the step's goal and then finds no target.
The e2e-tester checkpoint was chosen on one set of simulated test apps; the first row is a second set, opened once. Benchmark scores were used for reporting only.

How it works (MoQLE)

Trunk: qev-0.8b, unchanged (a full fine-tune of Qwen3.5-0.8B-Base: 24 layers, Gated DeltaNet + gated attention).
Experts: rank-64 LoRA on gate_proj, up_proj, down_proj of layers 12–23, y = W x + 2.0 · B A x, stored as 2-bit rows (specialists/slots_2bit.safetensors, 5.4 MB). Slot 1 = games, slot 2 = e2e.
Router: LayerNorm → Linear(1024, 256) → GELU → Linear(256, 9) on the mean of the RMS-normalised residual stream after layer 5 of the text prompt (specialists/router.safetensors, 1.1 MB). Top-1 of {none, games, e2e}. A request with an image never goes to the games expert.
The experts were trained by reinforcement learning only (closed-loop games and simulated web apps), with the trunk frozen.

Quickstart (NVIDIA GPU)

pip install -r requirements.txt -r requirements-cuda.txt

from qev import QEV

m = QEV.from_pretrained("labqoat/squad-0.8b", specialists=True)     # router + specialists (fast CUDA engine)
m.decide(state, questions)                                           # same API and answers as qev-0.8b
m.last_routes                                                        # e.g. ["e2e-tester"]
m.decide("Customer screenshot: <image:shot>", questions, images={"shot": "screen.png"})   # images work too

python qev_server.py --model labqoat/squad-0.8b --specialists     # POST http://127.0.0.1:8017/v1/systemone

Without specialists=True (or --specialists) you get qev-0.8b exactly. Experts need the fast CUDA engine (requirements-cuda.txt); on Apple silicon use the MLX version, elsewhere the GGUF version.

Files

model.safetensors and the tokenizer / config files (qev-0.8b's, unchanged) · specialists/ (manifest, router, 2-bit slots) · qev.py, qev_server.py, qev_fast/ (runner, server, CUDA engine with experts) · qev_image.py, qev_image_server.py (transformers image path, trunk only) · SHA256SUMS.

Limitations

Everything in qev-0.8b's card applies. In addition: two experts only (games, e2e); the e2e is far from reliable on real apps; the router is trained for these two skills and sends everything else to the plain model.

License: Apache-2.0.