Instructions to use VextLabsinc/juwel-beryl with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use VextLabsinc/juwel-beryl with Transformers:

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

pipe = pipeline("image-text-to-text", model="VextLabsinc/juwel-beryl")
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)

# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("VextLabsinc/juwel-beryl")
model = AutoModelForMultimodalLM.from_pretrained("VextLabsinc/juwel-beryl", 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=40)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use VextLabsinc/juwel-beryl with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "VextLabsinc/juwel-beryl"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "VextLabsinc/juwel-beryl",
		"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/VextLabsinc/juwel-beryl

SGLang

How to use VextLabsinc/juwel-beryl 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 "VextLabsinc/juwel-beryl" \
    --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": "VextLabsinc/juwel-beryl",
		"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 "VextLabsinc/juwel-beryl" \
        --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": "VextLabsinc/juwel-beryl",
		"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 VextLabsinc/juwel-beryl with Docker Model Runner:
```
docker model run hf.co/VextLabsinc/juwel-beryl
```
Browse Quantizations to use this model in llama.cpp, Ollama, LM Studio, or any compatible app.

JUWEL Beryl

80-layer vision-language base. The required base for all 16 JUWEL GEM adapters.

Read this first: safety refusals have been removed

Beryl is abliterated — refusal directions were ablated, so it will not reliably decline harmful requests. It ships with no safety layer. If you deploy it, you are responsible for adding your own filtering, policy, and human oversight. Do not treat this as an aligned assistant model. See USE_POLICY.md.

What this is


Architecture	`Qwen3VLForConditionalGeneration` (image-text-to-text)
Layers	80 (parent had 64; 16 added by CIP, parent's 64 frozen)
Hidden size	5120
Attention heads	64 (head dim 128) · 8 KV heads
Intermediate size	25600
Context window	262144 tokens (256K), `rope_type: default` — no extended-rope variant
Vision tower	27 layers, inherited from the parent
Vocab	151936 — Qwen's tokenizer, shipped unmodified
Precision	BF16 (verified in the shard headers, not just declared)
Size	76.7 GiB, 19 shards, 1234 tensors
Parent	Qwen3-VL-32B-Instruct (Apache-2.0)
License	Apache-2.0 — see `LICENSE` + `NOTICE`. AS IS, no warranty.

Internal lineage: theron-base-v9 plus one capability-injection rung. Layers 0–63 are the parent's frozen weights; layers 64–79 were added and trained.

Load it

from transformers import AutoModelForImageTextToText, AutoTokenizer

model = AutoModelForImageTextToText.from_pretrained(
    "VextLabsinc/juwel-beryl", torch_dtype="auto", device_map="auto")
tok = AutoTokenizer.from_pretrained("VextLabsinc/juwel-beryl")

Use AutoModelForImageTextToText, not AutoModelForCausalLM — this is a vision-language architecture and the causal-LM class will not load it.

Footprint: ~82 GB in BF16 (2x 48 GB GPUs or better), ~41 GB at FP8, ~21 GB at NF4.

The GEM adapters

Beryl is the base for 16 domain LoRA adapters (VextLabsinc/gem-*: ruby/code, aquamarine/math, spinel/reasoning, lapis/language, bloodstone/medical, sardonyx/legal, tanzanite/finance, peridot/science, topaz/engineering, citrine/business, opal/education, jade/humanities, pearl/reconciler, plus alexandrite, tourmaline, turquoise). Each is native to this exact 80-layer geometry (layers_to_transform 0–79, r=64) and is not interchangeable with other JUWEL bases.

from peft import PeftModel
model = PeftModel.from_pretrained(model, "VextLabsinc/gem-ruby")

Evaluation

Status: PENDING. No benchmark numbers are published for this model yet, and that is a real absence rather than a hidden result.

Until 2026-07-28 the GEM adapters named a 144-layer base in their cards while being native to 80 layers, so nothing in the release was loadable as trained and no valid benchmark could be produced. Publishing Beryl is what makes the fleet runnable. Structural compatibility is verified — all 560 target modules per adapter resolve against this model's tensor index — but output-quality evaluation requires GPU time and has not been completed.

When numbers arrive they will be BF16, measured on our own weights on our own hardware, with per-sample audit trails. We do not publish a score we cannot reproduce, and we will not present quantized screening runs as headline results.

Limitations

No refusal behavior. See the warning above. This is the single most important limitation.
Outputs can be wrong, biased, or harmful. Not a substitute for licensed professionals in medicine, law, finance, or security.
Unevaluated: no published capability numbers, so treat any assumption about its ability as unverified.
The 16 added layers were trained on a smaller data budget than the frozen parent.

Intended use

Research, evaluation, and authorized professional workflows where a human remains responsible for outcomes, and where the deployer supplies their own safety layer.

Prohibited use

See USE_POLICY.md. In short: no unauthorized system access, no malware or fraud, no CSAM, no weapons development, nothing violating applicable law. Publishing weights is not permission to break the law, and Vext Labs does not endorse misuse.

Liability

Provided AS IS under LICENSE. To the maximum extent permitted by law, Vext Labs, Inc. disclaims all warranties and is not liable for damages arising from use or misuse. You are solely responsible for lawful, authorized use.

Contact

https://vextlabs.ai · https://juwel.ai · info@vextlabs.ai

Downloads last month: 26

Safetensors

Model size

41B params

Tensor type

BF16

Model tree for VextLabsinc/juwel-beryl

Base model

Qwen/Qwen3-VL-32B-Instruct

Finetuned

(41)

this model

Adapters

16 models

Quantizations

2 models