Instructions to use xtools-at/Qwen3.8-27B-CodeForge-3xMerge with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use xtools-at/Qwen3.8-27B-CodeForge-3xMerge with Transformers:

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

pipe = pipeline("image-text-to-text", model="xtools-at/Qwen3.8-27B-CodeForge-3xMerge")
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("xtools-at/Qwen3.8-27B-CodeForge-3xMerge")
model = AutoModelForMultimodalLM.from_pretrained("xtools-at/Qwen3.8-27B-CodeForge-3xMerge", 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 xtools-at/Qwen3.8-27B-CodeForge-3xMerge with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "xtools-at/Qwen3.8-27B-CodeForge-3xMerge"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "xtools-at/Qwen3.8-27B-CodeForge-3xMerge",
		"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/xtools-at/Qwen3.8-27B-CodeForge-3xMerge

SGLang

How to use xtools-at/Qwen3.8-27B-CodeForge-3xMerge 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 "xtools-at/Qwen3.8-27B-CodeForge-3xMerge" \
    --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": "xtools-at/Qwen3.8-27B-CodeForge-3xMerge",
		"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 "xtools-at/Qwen3.8-27B-CodeForge-3xMerge" \
        --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": "xtools-at/Qwen3.8-27B-CodeForge-3xMerge",
		"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 xtools-at/Qwen3.8-27B-CodeForge-3xMerge with Docker Model Runner:
```
docker model run hf.co/xtools-at/Qwen3.8-27B-CodeForge-3xMerge
```

🛠️ Qwen3.8-27B Code Forge - 3x Merge

A three-way merge bringing together coding, reasoning, and distilled conversational capabilities.

Looking for quantizations/GGUFs? Click here

✨ Overview

This model is a weighted merge of three independently fine-tuned versions of Qwen3.8-27B. The idea behind the merge is fairly straightforward: combine different training approaches and strengths without leaning too heavily into just one specialization.

The three contributors bring complementary qualities:

Advanced coding, structured reasoning, and efficient thinking from nerkyor's Coder390 EfficientThink.
Conversational and knowledge-oriented distillation from TeichAI's Fable Distill.
Coding and agentic capabilities from Jackrong's Qwopus Coder Flash.

The goal is a versatile general-purpose model that can write and understand code, work through challenging problems, follow instructions, and handle longer reasoning tasks while avoiding unnecessary reasoning overhead.

⚖️ Merge Details

The model was created by merging the following checkpoints with these weights:

Model	Merge weight
nerkyor/Qwen3.8-27B-Coder390-EfficientThink-[...]	1.00
TeichAI/Qwen3.8-27B-Fable-Distill	0.85
Jackrong/Qwopus3.8-27B-Coder-Flash	0.70

All three models share Qwen3.8-27B as their underlying foundation.

The weights above are the merge coefficients, not percentages of training data or a claim about each model's relative contribution to a particular capability.

🧩 The Three Contributors

1. 🧠 Coder390 EfficientThink - nerkyor

Model card

This is the most extensively post-trained contributor of the three. It builds on nerkyor's own EfficientThink SFT + SimPO checkpoint, itself derived from the official Qwen3.8-27B model.

Its training combines multiple rounds of supervised fine-tuning (SFT) and Reinforcement Learning from Offline/Online-style comparisons (RLOO, as described in the upstream recipe).

The training provenance is particularly interesting:

Opus 5.5 and GPT-6 Astra: contributed gold answers and teacher trajectories.
Grok 4.7: hosted the training run and helped check and filter data.
DeepSeek V4 Pro and K3: contributed teacher trajectories.
K3: additionally contributed problem writing and RLOO value review.

The EfficientThink objective is to reduce unproductive reasoning loops and runaway thought sequences without removing the ability to reason deeply when a problem actually requires it.

The Coder390 name reflects the author's stated GPQA, MMLU, and LiveCodeBench performance targets. The upstream model also includes MTP and DFlash2 speculative-decoding components.

This contributor brings additional reasoning refinement, coding specialization, and an explicit focus on efficient problem-solving.

2. 📖 Qwen3.8-27B-Fable-Distill - TeichAI

Model card

Fable Distill is a relatively light fine-tune of Qwen3.8-27B, trained on a combination of publicly identified Fable datasets and a larger private corpus of Fable 5 data.

The two publicly listed datasets are:

armand0e/claude-fable-5-claude-code - Claude/Fable-oriented coding traces.
armand0e/Fable-5-Chat - Fable 5 conversational examples.

The model's stated goal is to transfer useful Fable 5 conversational and problem-solving behavior into the Qwen3.8 architecture. Its published ARC Challenge and BoolQ results also suggest an emphasis on retaining and improving general knowledge and instruction-following capabilities.

This contributor adds a different flavor to the merge: conversational ability, knowledge-oriented responses, and distilled teacher behavior.

3. ⚡ Qwopus3.8-27B-Coder-Flash - Jackrong

Model card

A coding-focused fine-tune built on Qwen3.8-27B, with an emphasis on practical software engineering and agentic workflows.

Its training philosophy revolves around making each token count: understanding a task, planning an implementation, using tools, inspecting feedback, fixing errors, and delivering a working result.

The published training recipe describes approximately 200K code and reasoning examples, covering agent interactions, algorithmic problems, code generation, and logical reasoning. Its data sources include teacher-generated examples from Qwen3.8-Flash-Max, Qwen3.8-Max, DeepSeek-V4-Flash, and the NVIDIA Nemotron ecosystem.

This contributor is intended to bring strong implementation skills, code quality, tool-use behavior, and more purposeful reasoning.

🎯 Intended Use

The merged model is intended for:

Software development, code generation, debugging, and refactoring.
Complex reasoning, mathematics, and multi-step problem-solving.
Agentic workflows involving tool use and iterative execution.
General instruction following and conversational tasks.
Technical explanations, analysis, and knowledge-intensive queries.
Tasks where useful reasoning matters more than simply producing long reasoning traces.

It should be considered an experimental general-purpose merge rather than a model optimized for just one benchmark or task.

⚠️ Limitations

This is a weight-space merge, not a new round of supervised fine-tuning or reinforcement learning. Combining checkpoints does not guarantee that every capability of every contributor will be preserved.

Potential limitations include:

Inconsistent behavior between different types of coding and reasoning tasks.
Changes in response style or reasoning length.
Reduced performance in some specialized tasks compared with an individual contributor.
Tool-calling behavior that may depend on the inference engine and chat template.
No independent benchmark results are claimed for this merged checkpoint.

As always, generated code and reasoning should be checked before being used in production or other consequential settings.

🙏 Credits and Acknowledgements

A big thank-you to the people behind the three upstream models and to the wider Qwen ecosystem.

Special thanks to:

Qwen for the Qwen3.8-27B foundation model.
Jackrong for the Qwopus coding and agentic fine-tune.
TeichAI for Fable Distill.
nerkyor for the EfficientThink and Coder390 training work.
The contributors to the upstream datasets and teacher-model ecosystems.

This merge builds on their work rather than replacing it. Please visit and credit the original repositories when using or redistributing the model.

📜 License

The three listed upstream model repositories specify Apache-2.0. This model card uses the same license designation; users should review the upstream model and dataset terms and any applicable third-party terms before redistribution or commercial use.