Qwen3.5 122B-A10B — open-weight MoE multimodal (text/image/video), 122B total / 10B active params, 32k context (vision mode).
Qwen3.5-122B-A10B is a large language model from the Qwen series by Alibaba Cloud. It uses a mixture-of-experts (MoE) architecture where only 10 billion parameters are activated per forward pass,…
Based on its architectures and benchmark score, Qwen3.5-122B-A10B excels at tasks that involve multi-step reasoning, tool use, and instruction following. The τ²-Bench score of 93.6 indicates strong performance on a benchmark that requires the model to plan and execute sequences of actions using tools (e.g., calculators, search engines, code interpreters). This makes it suitable for building autonomous agents that need to interact with external systems. The model also handles multimodal inputs, so tasks like visual reasoning, document analysis with embedded images, or video summarization are within its strengths. Additionally, its large output limit allows it to generate thorough explanations, code completions, or structured data in a single response. Developers working on complex chatbots, coding assistants, or research analysis tools may find this model effective.
While Qwen3.5-122B-A10B is powerful, it is not the most cost-efficient choice for every use case. If your task is a simple classification, short text generation, or a straightforward Q&A that does not require multi-step reasoning or multimodal understanding, you may achieve satisfactory results with a smaller model like Qwen-7B or a non-multimodal model. Those models can be faster and cheaper per token. Also, if your context needs are very small (e.g., less than 1,000 tokens), the relative overhead of using a 122B parameter model may not be worthwhile. OrcaRouter offers a range of models with different pricing and performance characteristics. You can experiment with smaller models first and upgrade only if the quality is insufficient. Additionally, if you do not need the 65K output limit, a model with a shorter output may suffice.
The model has a context window of 32,768 tokens and a maximum output of 65,536 tokens, which allows it to handle extended reasoning chains and long instructions. The high τ²-Bench score suggests it can maintain coherence over multiple steps and correctly follow complex instructions that involve conditional logic, tool calls, and branching. In practice, users have reported that the Qwen3.5 series models are competitive with other state-of-the-art models on tasks like mathematical problem solving, code generation, and logic puzzles. However, like all large models, performance can degrade if the context is packed with irrelevant information or if the instructions are ambiguous. Prompt engineering is recommended to guide the model effectively. The model may also have difficulty with very long documents (close to the context limit) where it must recall details from the beginning.
The multimodal input (text + image/video) enables several practical applications. In document analysis, the model can read both the text and embedded charts, diagrams, or signatures within a PDF or image. For example, it can extract data from a scanned table or interpret a graph. In visual question answering, the model can answer questions about a photograph or illustration. In video analysis, it can process frames to describe scenes or track changes over time. Developers can build tools for accessibility (e.g., describing images for visually impaired users) or automation (e.g., analyzing UI screenshots). Because the model is accessed via OrcaRouter, these capabilities can be integrated into existing applications with the same API calls used for text-only prompts, simply by including image_url or video_url in the message content.
The only publicized benchmark for this model is the τ²-Bench, where it scored 93.6. τ²-Bench is designed to evaluate a model's ability to use tools and complete multi-step tasks in a simulated environment. A score of 93.6 indicates that the model can correctly complete a high proportion of these tasks. For context, this score is competitive with other state-of-the-art models on the same benchmark. However, benchmark scores do not always translate to real-world performance, as tasks can vary in difficulty and the benchmark may not cover all domains. Users should conduct their own evaluations on their specific tasks. No other benchmark scores (e.g., MMLU, HumanEval, or multimodal benchmarks) are provided in the available facts, so it is not possible to compare this model on a broader set of standard metrics.
Strengths: The model achieves a high score on a tool-use benchmark, suggesting strong reasoning and instruction following. Its multimodal capability and large output limit make it versatile. The MoE architecture may provide a good balance between performance and efficiency (at least compared to a dense model of similar total parameters). Limitations: The model has a context window of only 32,768 tokens, which is moderate compared to some models offering 100K or more. The activated parameters (10B) are relatively low for a model of its total size, which might cap performance on very complex tasks. No information is available about latency, throughput, or hardware requirements. Also, because the model is new, the community ecosystem (e.g., finetuning scripts, quantization tools) may be less developed than for more established models. Users should test the model thoroughly.
No specific latency or throughput figures are available for this model on OrcaRouter. The speed of inference depends on factors such as the input length, output length, batch size, and the underlying hardware that OrcaRouter allocates. MoE models can have variable speed because the routing mechanism may activate different experts for different tokens. Generally, models with 10B activated parameters can generate at moderate speeds on modern GPUs, but the total 122B parameters in memory may lead to higher memory usage and longer prefill times. If low latency is critical, you may want to test the model with your typical prompts. OrcaRouter's API returns timestamps and performance metrics in the response headers that can help you measure speed. For latency-sensitive applications, consider using a smaller model if the task allows.
The available facts only include a single benchmark: τ²-Bench. Common benchmarks such as MMLU (knowledge), HumanEval (code), GSM8K (math), or multimodal benchmarks like MMBench are not provided. This makes it difficult to gauge the model's performance on tasks that are not tool-related. For example, if your application requires factual accuracy, you would want to know its performance on MMLU. Similarly, for multimodal tasks, scores on a visual reasoning benchmark would be useful. The absence of these scores does not imply poor performance, but it means that users must conduct their own evaluations. OrcaRouter may provide additional benchmark results upon request or in documentation. Until more data is available, it is advisable to compare the model qualitatively with others on your specific domain.
Pricing details for Qwen3.5-122B-A10B on OrcaRouter are not explicitly provided in the available facts. Typically, OrcaRouter charges per token for both input and output, with separate rates for prompt tokens and generated tokens. Multimodal inputs (images/video) are billed as token equivalents based on the number of image blocks or video frames processed. Some providers also offer discounted rates for cache hits if the user repeats the same prompt. To get exact pricing, users should refer to OrcaRouter's pricing page or contact their sales team. Because this model has 122B total parameters and is multimodal, its per-token price may be higher than that of smaller or text-only models. It is important to factor in the token cost for images/video when estimating total expenses for a task.
Using a larger model like Qwen3.5-122B-A10B typically incurs higher per-token costs than smaller models. However, if the model can solve a task in fewer steps or with fewer tokens due to its capabilities, the total cost may still be competitive. The large output limit (65,536 tokens) can be both a benefit and a cost risk: generating long outputs can quickly accumulate token costs. Additionally, multimodal inputs consume more tokens per prompt than text-only prompts. For example, a single high-resolution image may cost hundreds of tokens. If your task does not require the model's full capabilities, you may save money by choosing a smaller model. OrcaRouter likely provides usage dashboards and cost controls, such as setting a maximum number of output tokens or budget alerts, which can help manage expenses.
The available facts do not mention any caching discounts for this model on OrcaRouter. Many inference providers offer prompt caching, where repeated text in system prompts or user messages is stored temporarily and billed at a lower rate. If OrcaRouter supports caching, it could reduce costs for applications that use long static prompts (e.g., system instructions, character descriptions). However, without specific documentation, it should not be assumed. Users can check the API response headers for cache hit indicators if caching is implemented. To minimize costs, you can design prompts to avoid repeating the same long prefixes by separating static instructions from dynamic content. Also, consider using shorter context windows or omitting unnecessary images when possible.
To use Qwen3.5-122B-A10B, send a POST request to the OrcaRouter API endpoint at https://api.orcarouter.ai/v1/chat/completions. Set the model parameter to "qwen/qwen3.5-122b-a10b". The API is fully compatible with OpenAI's chat completions format, so you can use the same client libraries (e.g., openai Python library) by changing the base URL and API key. The body of the request includes messages (each with a role and content), and optionally parameters like temperature, max_tokens, top_p, etc. For multimodal input, use a content block with type: "image_url" for images or the model's specific video handling (likely via base64 encoded frames or a URL). The API will return a JSON response with the generated text and usage metadata (token counts). OrcaRouter documentation provides more details on supported parameters.
The model supports the standard chat parameters: temperature (default typically 0.7), top_p (default 0.9), max_tokens (up to the model's maximum output of 65,536), presence_penalty, frequency_penalty, and stop sequences. The context window limit is 32,768 tokens, which includes all messages, images, and video frames. If the total token count exceeds this limit, the API will return an error or truncate the input (depending on settings). The max_tokens parameter cannot exceed 65,536. For multimodal requests, note that images and videos add tokens; the exact conversion rate is not provided, but high-resolution or long videos can quickly consume the context window. OrcaRouter may also support stream mode, where responses are streamed token-by-token, which is useful for real-time applications. Check the API reference for additional options like logprobs or tools.
Migrating is straightforward: replace your base URL to https://api.orcarouter.ai/v1, use the model ID "qwen/qwen3.5-122b-a10b", and provide your OrcaRouter API key. The request format is identical to the OpenAI chat completions API. For example, in Python with the openai library, you can set client = OpenAI(base_url='https://api.orcarouter.ai/v1', api_key='your_key'). Then call client.chat.completions.create(model='qwen/qwen3.5-122b-a10b', messages=...). If your application uses function calling or tools, note that the model supports them as it is trained on τ²-Bench which involves tool use. However, the exact tool call syntax may differ from OpenAI's; OrcaRouter likely supports the OpenAI format but test to confirm. For multimodal inputs, your existing code that sends image_url in messages may work as long as the model supports that format.
Within the Qwen family, this model sits between smaller dense models (e.g., Qwen-7B, Qwen-14B) and the largest MoE models (e.g., Qwen3.5-235B). Compared to dense models, this MoE model can access a larger total parameter set but activates only a fraction per token, which may allow for more specialized experts. This can lead to better performance on a variety of tasks, especially those requiring diverse knowledge. However, smaller dense models can be faster and cheaper for narrow tasks. Compared to the larger Qwen3.5-235B, this model likely has lower performance but is more efficient. The multimodal support is a common feature of the Qwen3.5 generation; earlier versions (Qwen2, Qwen1) were text-only. Users should compare benchmark results on their specific tasks to decide which model fits best.
Direct comparisons are difficult without comprehensive benchmarks. Qwen3.5-122B-A10B achieves 93.6 on τ²-Bench, which is a strong result for tool-use tasks. For reference, similar scores on that benchmark for other models are not provided, but it is considered a high-level capability. In terms of architecture, Llama models are dense and simpler, while Claude models have different proprietary architectures. Qwen3.5 offers multimodal input (image/video) which Claude supports but Llama 3.2 and 3.1 are text-only (except for some vision variants). The context window of 32K is smaller than Claude's 100K or 200K but comparable to Llama 3.1's 128K? Not exactly; we must not invent numbers. For code and reasoning, many models are competitive. This model's advantage may be its specific tuning for tool use (τ²-Bench high score) and multimodal MoE efficiency. However, Claude and Llama have larger ecosystems and more community support.
Few models combine multimodal input, a large context window, a large output limit, and a high τ²-Bench score in one package. The Qwen3.5 series is designed to be a capable general-purpose model with strong reasoning and tool-use skills. The MoE architecture with 122B total and 10B active allows it to pack a lot of knowledge while keeping inference costs lower than a dense 122B model. That said, other MoE models like Mixtral 8x7B (total 47B, active 13B) have different trade-offs. Qwen3.5-122B-A10B has a much larger total parameter count but fewer active parameters per token (10B vs. 13B). The multimodal support is a differentiator; Mixtral is text-only. In the multimodal MoE space, models like Qwen-VL or others exist but often have smaller context windows. This model is positioned as a strong option for developers who need a single model for diverse, multimodal, and tool-heavy tasks on OrcaRouter.
Choose Qwen3.5-122B-A10B if your application requires both multimodal understanding and complex multi-step reasoning, and you need the large output limit for generating long responses. It is also a good choice if you are building agentic systems that use tools, given its high τ²-Bench score. If your task is text-only and does not need the extra capacity, a cheaper model like Llama 3.1 70B or Qwen-14B may suffice. If you need a larger context window (e.g., >100K tokens), consider models specifically designed for long context. If you need lower latency, a smaller or dense model may be better. Since OrcaRouter offers many models, you can evaluate multiple via the same API to find the best fit for your cost and quality targets. The model ID is qwen/qwen3.5-122b-a10b.
OpenAI-compatible — keep the SDK you already use
https://api.orcarouter.ai/v1from openai import OpenAI
client = OpenAI(
base_url="https://api.orcarouter.ai/v1",
api_key="$ORCAROUTER_API_KEY",
)
response = client.chat.completions.create(
model="qwen/qwen3.5-122b-a10b",
messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)enable_searchenable_thinkinginclude_reasoninglogprobsmax_tokensnparallel_tool_callspresence_penaltyreasoningrepetition_penaltyresponse_formatseedstopstreamstream_optionstemperaturethinking_budgettool_choicetoolstop_ktop_logprobstop_p| Tier | Input / 1M tokens | Output / 1M tokens |
|---|---|---|
| ≤ 128K | $0.115 | $0.917 |
| ≤ 256K | $0.287 | $2.294 |
| Tier selected by input token count of each request | ||
Estimate based on list price
Tiered pricing — this estimate uses base-tier rates.
Estimate only — actual token counts depend on the provider's tokenizer.
GET /api/public/models/qwen/qwen3.5-122b-a10bOpen @misc{orcarouter_qwen3_5_122b_a10b,
title = {Qwen3.5-122B-A10B API},
author = {Qwen},
year = {2026},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/qwen/qwen3.5-122b-a10b}
}Qwen. (2026). Qwen3.5-122B-A10B API. OrcaRouter. https://www.orcarouter.ai/models/qwen/qwen3.5-122b-a10b