CrowdMind Qwen3.5-9B-Pro

CrowdMind presents Qwen3.5-9b-pro, a supervised fine-tuned version of Qwen/Qwen3.5-9B.

The checkpoint is designed for agentic workflows, coding, tool use, automation, and general-purpose reasoning. It also retains the multimodal message structure of the Qwen3.5 family, allowing image and video inputs through the supplied processor and custom chat template.

Model: CrowdMind/Qwen3.5-9b-pro
Base model: Qwen/Qwen3.5-9B
Developer: CrowdMind / Dustin Loring
Training method: Supervised fine-tuning (SFT)
License: MIT

---

Evaluation

Results for the released SFT checkpoint.

Domain	Benchmark	Metric	Qwen3.5-9B	Qwen3.5-9b-pro (SFT)
Code	SWE Pro	avg@3	32.0	44.6
General	AutomationBench v1.0.6	avg@1	5.0	30.3
General	Terminal Bench 2.1	avg@1	27.0	37.1
General	Toolathlon-Verified	avg@1	25.9	35.2
General	OfficeQA	avg@1	9.0	19.5
General	JobBench	avg@1	2.6	18.3

These numbers are provided for the released SFT checkpoint and should be interpreted in the context of the benchmark versions and metrics shown above.

---

What is different about this model?

Qwen3.5-9b-pro is an SFT checkpoint built from Qwen/Qwen3.5-9B.

The model is intended for workflows where the model needs to do more than produce a simple conversational answer, including:

• Agentic task execution
• Code generation and modification
• Tool-use workflows
• Terminal and automation tasks
• General reasoning
• Structured responses
• Multimodal understanding of images
• Multimodal understanding of videos

The model repository includes the tokenizer/processor configuration and the custom chat template used for inference.

---

Chat Template

This model uses the CrowdMind Qwen3.5 chat template included with the checkpoint.

Do not replace the supplied template with an unrelated generic chat template. The template is responsible for formatting normal conversations, controlling thinking behavior, and inserting the correct multimodal placeholders for image and video inputs.

The template supports:

• Text content
• Image content
• Video content
• Thinking enabled/disabled
• low reasoning effort
• medium reasoning effort
• xhigh reasoning effort
• Generation prompts

For multimodal messages, the template maps images to:

<|vision_start|><|image_pad|><|vision_end|>

and videos to:

<|vision_start|><|video_pad|><|vision_end|>

Vision inputs should be supplied as structured content items rather than manually placing these special tokens into the user's prompt.

Important: The custom template does not allow image or video content in a system message. Put vision inputs in the user message.

---

Quickstart with SGLang

For text generation, use a recent SGLang build with Qwen3.5 support.

Start the server:

sglang serve \
  --model-path CrowdMind/Qwen3.5-9b-pro \
  --reasoning-parser mimo \
  --host 0.0.0.0 \
  --port 30000

Then query the OpenAI-compatible endpoint:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:30000/v1",
    api_key="EMPTY",
)

response = client.chat.completions.create(
    model="CrowdMind/Qwen3.5-9b-pro",
    messages=[
        {
            "role": "user",
            "content": "What is 15% of 240?"
        }
    ],
    max_tokens=2048,
    extra_body={
        "chat_template_kwargs": {
            "enable_thinking": True
        }
    },
)

message = response.choices[0].message

print("Thinking:", getattr(message, "reasoning_content", "") or "")
print("Answer:", message.content or "")

---

Thinking and Reasoning

The supplied chat template provides explicit controls for reasoning.

Three reasoning-effort levels are supported:

Setting	Intended behavior
low	Short, focused reasoning
medium	Detailed reasoning
xhigh	More extensive reasoning and verification

Thinking can also be disabled entirely.

Enable thinking

response = client.chat.completions.create(
    model="CrowdMind/Qwen3.5-9b-pro",
    messages=[
        {
            "role": "user",
            "content": "Explain why the sky appears blue."
        }
    ],
    max_tokens=2048,
    extra_body={
        "chat_template_kwargs": {
            "enable_thinking": True,
            "reasoning_effort": "medium",
        }
    },
)

Low reasoning

extra_body={
    "chat_template_kwargs": {
        "enable_thinking": True,
        "reasoning_effort": "low",
    }
}

Medium reasoning

extra_body={
    "chat_template_kwargs": {
        "enable_thinking": True,
        "reasoning_effort": "medium",
    }
}

XHigh reasoning

extra_body={
    "chat_template_kwargs": {
        "enable_thinking": True,
        "reasoning_effort": "xhigh",
    }
}

Disable thinking

extra_body={
    "chat_template_kwargs": {
        "enable_thinking": False,
    }
}

When thinking is disabled, the chat template creates the appropriate empty thinking block before the assistant response.

---

Multimodal Input

The model's chat format supports structured multimodal content.

A user message can contain:

[
    {
        "type": "image",
        "image": "...",
    },
    {
        "type": "text",
        "text": "Describe this image.",
    },
]

or:

[
    {
        "type": "video",
        "video": "...",
    },
    {
        "type": "text",
        "text": "Describe what happens in this video.",
    },
]

The media should be supplied to the processor/runtime rather than manually inserting <|image_pad|> or <|video_pad|> tokens.

---

Image Understanding

Image with a URL

With a multimodal runtime that accepts OpenAI-compatible content blocks:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:30000/v1",
    api_key="EMPTY",
)

response = client.chat.completions.create(
    model="CrowdMind/Qwen3.5-9b-pro",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://example.com/image.jpg"
                    },
                },
                {
                    "type": "text",
                    "text": "Describe this image in detail.",
                },
            ],
        }
    ],
    max_tokens=1024,
)

print(response.choices[0].message.content)

The exact accepted URL/media transport depends on the serving runtime. When using Transformers directly, use the model's AutoProcessor and the repository's structured image content format shown below.

Transformers image example

import torch
from transformers import AutoProcessor, AutoModelForImageTextToText

MODEL_ID = "CrowdMind/Qwen3.5-9b-pro"

processor = AutoProcessor.from_pretrained(MODEL_ID)

model = AutoModelForImageTextToText.from_pretrained(
    MODEL_ID,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "image",
                "image": "/path/to/image.jpg",
            },
            {
                "type": "text",
                "text": "What objects are visible in this image?",
            },
        ],
    }
]

inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
)

inputs = {
    key: value.to(model.device) if hasattr(value, "to") else value
    for key, value in inputs.items()
}

with torch.inference_mode():
    output_ids = model.generate(
        **inputs,
        max_new_tokens=512,
    )

output_ids = output_ids[:, inputs["input_ids"].shape[1]:]

answer = processor.batch_decode(
    output_ids,
    skip_special_tokens=True,
)[0]

print(answer)

---

Multiple Images

Multiple images can be included in the same user message.

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "image",
                "image": "/path/to/image1.jpg",
            },
            {
                "type": "image",
                "image": "/path/to/image2.jpg",
            },
            {
                "type": "text",
                "text": "Compare these two images and explain the differences.",
            },
        ],
    }
]

This is useful for:

• Image comparison
• Before/after analysis
• Multi-image question answering
• Document comparison
• Visual inspection workflows

---

Video Understanding

The custom chat template also supports video content.

A video message uses:

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "video",
                "video": "/path/to/video.mp4",
            },
            {
                "type": "text",
                "text": "Describe what happens in this video.",
            },
        ],
    }
]

The chat template represents the video internally as:

<|vision_start|><|video_pad|><|vision_end|>

The processor/runtime is responsible for preparing the actual video input.

Video with a local file

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "video",
                "video": "/path/to/video.mp4",
            },
            {
                "type": "text",
                "text": "Summarize the events in this video chronologically.",
            },
        ],
    }
]

Video analysis example

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "video",
                "video": "/path/to/security_camera.mp4",
            },
            {
                "type": "text",
                "text": (
                    "Analyze the video and describe the important events, "
                    "including what changes over time."
                ),
            },
        ],
    }
]

Video preprocessing support can vary by Transformers/SGLang version and hardware configuration. Use a recent runtime with Qwen3.5 multimodal support.

---

Image + Video in One Conversation

The content format also allows different modalities to appear together.

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "image",
                "image": "/path/to/start.jpg",
            },
            {
                "type": "video",
                "video": "/path/to/process.mp4",
            },
            {
                "type": "text",
                "text": (
                    "The image shows the starting state and the video shows "
                    "what happened afterward. Explain the changes."
                ),
            },
        ],
    }
]

This format is useful for workflows such as:

• Before/after inspection
• Product demonstrations
• Video-grounded question answering
• Visual debugging
• Robotics and physical-world tasks
• Agentic workflows involving visual observations

---

Multimodal + Reasoning

Vision inputs can be combined with the reasoning controls.

For example:

inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    enable_thinking=True,
    reasoning_effort="medium",
)

For a shorter response:

inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    enable_thinking=True,
    reasoning_effort="low",
)

For more extensive reasoning:

inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    enable_thinking=True,
    reasoning_effort="xhigh",
)

---

Structured Content Format

The preferred message structure is:

Text

{
    "type": "text",
    "text": "Your question here"
}

Image

{
    "type": "image",
    "image": "/path/to/image.jpg"
}

Video

{
    "type": "video",
    "video": "/path/to/video.mp4"
}

These items can be combined in the content list of a user message.

For example:

{
    "role": "user",
    "content": [
        {
            "type": "image",
            "image": "/path/to/image.jpg"
        },
        {
            "type": "text",
            "text": "What is happening here?"
        }
    ]
}

---

Tool Use and Agentic Workflows

The model is tagged for agentic and tool-use applications.

A typical tool-oriented conversation can be represented as normal structured messages, with the serving framework responsible for the actual tool execution.

Example application flow:

User
  ↓
Qwen3.5-9b-pro
  ↓
Tool selection / action
  ↓
External tool
  ↓
Tool result
  ↓
Qwen3.5-9b-pro
  ↓
Final response

For production agent systems, validate tool calls and arguments before executing external actions.

---

Recommended Inference Settings

A reasonable starting point for general generation is:

max_tokens=2048

For coding and agentic tasks, increase the output budget when the task requires longer tool interactions or code.

For concise responses:

enable_thinking=False

For lightweight reasoning:

enable_thinking=True
reasoning_effort="low"

For general reasoning:

enable_thinking=True
reasoning_effort="medium"

For difficult reasoning tasks:

enable_thinking=True
reasoning_effort="xhigh"

Actual generation settings should be tuned for the deployment workload.

---

Loading with Transformers

The checkpoint can be loaded with Transformers using the processor and model configuration supplied by the repository.

import torch
from transformers import (
    AutoProcessor,
    AutoModelForImageTextToText,
)

MODEL_ID = "CrowdMind/Qwen3.5-9b-pro"

processor = AutoProcessor.from_pretrained(MODEL_ID)

model = AutoModelForImageTextToText.from_pretrained(
    MODEL_ID,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

Use a recent Transformers release with Qwen3.5 support.

If your installed Transformers version does not recognize the model or processor, upgrade Transformers before attempting multimodal inference.

---

Limitations

This model is an SFT checkpoint and may produce incorrect, incomplete, or overconfident outputs.

Important limitations include:

• Benchmark results do not guarantee performance on individual tasks.
• Tool calls should be validated before execution.
• Generated code should be reviewed and tested before deployment.
• Visual interpretations can contain errors.
• Video analysis can miss events or details depending on preprocessing, sampling, resolution, and context limits.
• Long conversations can exceed the available context window.
• Reasoning output should not be treated as a guarantee of correctness.
• Performance can vary substantially with prompting, runtime, sampling settings, and tool configuration.

This model should be evaluated on the specific workloads and safety requirements of the intended application.

---

Intended Use

CrowdMind/Qwen3.5-9b-pro is intended for research, experimentation, and applications involving:

• General language generation
• Coding
• Software engineering assistance
• Agentic workflows
• Tool use
• Automation
• Terminal-oriented tasks
• Multimodal image understanding
• Multimodal video understanding
• Reasoning and problem solving

Users are responsible for evaluating the model for their particular deployment and ensuring that its use complies with applicable laws, policies, and organizational requirements.

---

Base Model

This model is a fine-tuned version of:

Qwen/Qwen3.5-9B

Please refer to the base model repository for the upstream model's architecture, pretraining information, capabilities, and applicable documentation.

---

Citation

If you use this model, please reference the model repository:

CrowdMind/Qwen3.5-9b-pro

The model was released by CrowdMind and developed by Dustin Loring.

---

License

This repository is released under the MIT License.

See the repository license file for the complete license text.

---

Acknowledgements

CrowdMind acknowledges the Qwen team and the contributors to the Qwen/Qwen3.5-9B base model.

This model would not exist without the underlying Qwen3.5 model and the broader open-source ML ecosystem.