Qwen3.6 35B-A3B — open-weight MoE multimodal (text/image/video), 35B total / 3B active params, 256k context.
Qwen3.6 35B A3B is a mixture-of-experts (MoE) large language model from the Qwen family. It contains 35 billion total parameters, but only about 3 billion are activated during each forward pass. This…
Qwen3.6 35B A3B excels at tasks that benefit from long context windows and multimodal understanding. These include document-level question answering, summarization of lengthy reports, code generation with extended context, and complex reasoning over multiple steps. The model's 262,144-token context allows it to ingest entire books, extensive codebases, or hours of transcribed video. Its strength on τ²-Bench (95.3) indicates strong performance in tasks that require retrieving and using information from long inputs, as well as calling external tools and adhering to instructions across many turns. Multimodal inputs—images and videos—add the ability to analyze visual content alongside text in a single prompt.
The model supports input in the form of text, images, and video files. When sending a request via OrcaRouter's API, you can include image data (e.g., base64-encoded or URL) and video files within the user message, following the same multimodal format used by other providers. The model processes these visual elements jointly with the text prompt, allowing it to reason about charts, diagrams, photographs, or video clips. For example, you can ask it to describe a scene from a video, extract data from an image, or combine text instructions with visual context. Output is always text. There is no separate pricing for multimodal inputs—they are billed at the same per-token input rate.
The 262,144-token context window allows the model to handle very long sequences without truncation. However, long-context processing can increase latency and memory usage. The MoE architecture helps mitigate cost because only 3B parameters are active per token, but the full attention mechanism still scales with sequence length. On tasks where the relevant information is scattered across a long input, Qwen3.6 35B A3B's high τ²-Bench score suggests it can retrieve and reason effectively. For very long documents, consider chunking strategies or use the model's own summarization capabilities. For tasks with short context, a cheaper, dense model may be more economical.
If your use case involves short prompts (under 4K tokens), simple tasks like classification or extraction, or does not require multimodal input, a smaller, dense model—such as a 7B-parameter variant—may offer lower latency and cost. The per-token price of Qwen3.6 35B A3B ($0.25/$1.48 per million tokens) is moderate, but for high-volume, low-complexity workloads, a model with even lower active parameters (e.g., 1B or 3B dense) could be more cost-effective. Additionally, if you do not need the long context or multimodal capabilities, you are paying for overhead you may not use. Evaluate your average prompt and output lengths against the model's strengths to decide.
τ²-Bench is a benchmark that evaluates a model's ability to perform long-context reasoning and multi-step tool use. It involves processing a large corpus (e.g., a database of documents or a codebase) and then answering questions that require retrieving and synthesizing information from that corpus. A score of 95.3 indicates that the model successfully handled these tasks with high accuracy, outperforming many other models on this specific benchmark. It suggests strong retrieval, reasoning, and instruction-following capabilities over extended contexts. However, benchmark scores should be interpreted as one measure of performance; real-world results may vary depending on task specifics.
Latency for Qwen3.6 35B A3B is influenced by its MoE architecture: only 3B parameters are active per token, which generally allows faster inference than a dense 35B model. However, the attention mechanism still requires processing the full context window, so longer inputs increase time to first token. OrcaRouter does not publish specific latency benchmarks for this model. In practice, response times depend on request load, prompt length, and output token count. For real-time applications, test with your typical inputs. For batch processing, the model's cost efficiency can offset longer latencies. Users should consider both speed and cost when comparing to dense models.
The primary benchmark result provided is the τ²-Bench score of 95.3, which indicates strong long-context and tool-use reasoning. This is a key strength area. The model's multimodality also positions it well for tasks that combine visual and textual data, though no separate benchmark scores for visual tasks are provided here. Based on the architecture, one can expect the model to perform well on tasks that benefit from the large parameter count but do not require full activation of all parameters. The MoE design may lead to slightly less consistency compared to dense models on certain narrow tasks, but it offers a favorable trade-off between capability and cost.
While the τ²-Bench score is high, it is a single benchmark; performance on other benchmarks (e.g., MMLU, MATH, coding contests) is not provided. The model's dense counterparts (e.g., a full 35B dense model) may outperform on tasks that require all parameters to be simultaneously engaged, such as certain mathematical reasoning or multilingual tasks. Also, multimodal input is supported but the quality of video understanding may depend on frame sampling and compression. Latency is not benchmarked publicly. Users should not assume the model is the best choice for every scenario; always evaluate against your specific use case and consider running your own benchmarks.
Pricing is per token, billed separately for input and output. The cost is $0.25 per 1 million input tokens and $1.48 per 1 million output tokens. These are the provider's rates, and OrcaRouter applies zero markup. Input tokens include all tokens in the prompt, including text, image tokenization, and video tokenization. Output tokens are all tokens generated in the response. There are no additional fees for using the API, no monthly subscriptions, and no minimum usage requirements. Billing is handled by OrcaRouter based on token usage. Because only 3B parameters are active per token, the compute cost to the provider is lower than a dense 35B model, and this savings is passed through in the pricing.
The input price ($0.25/1M tokens) is relatively low, while the output price ($1.48/1M) is higher, reflecting the cost of generation. If your application outputs a large number of tokens (e.g., long summaries, code generation), the output cost will dominate. In such cases, consider reducing output length via instructions or using a cheaper model for generation if quality allows. Conversely, if you have very long prompts but short outputs, the input cost is favorable. The MoE architecture means that the inference cost per token is lower than a dense model of similar total parameters, but the pricing here is set at the provider's rate; you are paying for the efficiency.
OrcaRouter does not publicly disclose whether prompt caching is available for this model. If caching were implemented, it could reduce costs by avoiding re-encoding of identical prompt prefixes. However, no such feature is mentioned for this model specifically. Users should assume that every request is billed at the standard per-token rates. For repetitive prompts, consider grouping queries or using shorter prefixes to minimize input token usage. You can also monitor token counts via the API response usage field to optimize costs. For enterprise-scale usage, contact OrcaRouter to discuss potential custom arrangements or caching support.
Zero markup means OrcaRouter charges you exactly the same per-token price set by the model provider (Qwen). No additional platform fees, overhead, or profit margin is added. The $0.25/1M input and $1.48/1M output are the provider's own rates. This is transparency in pricing; you pay only for the underlying inference cost. OrcaRouter still manages the API infrastructure, routing, and billing but does not charge extra for that service. This can make Qwen3.6 35B A3B more economical compared to some other platforms that might add a markup. However, you may still need to compare total costs including any volume discounts or credits offered by OrcaRouter separately.
Use the OpenAI-compatible chat completions endpoint at https://api.orcarouter.ai/v1. Set the model parameter to "qwen/qwen3.6-35b-a3b". Construct messages as you would with OpenAI's API, including a system message if desired, and user messages. For multimodal input, include an array of content parts with type "text" and "image_url" (or "video_url"). Example (pseudocode): curl https://api.orcarouter.ai/v1/chat/completions -H "Authorization: Bearer YOUR_ORCAROUTER_API_KEY" -d '{"model":"qwen/qwen3.6-35b-a3b","messages":[{"role":"user","content":[{"type":"text","text":"Describe this image"},{"type":"image_url","image_url":{"url":"https://example.com/photo.jpg"}}]}]}'. The response follows the OpenAI format with choices, usage, etc.
Standard OpenAI parameters are supported: temperature (0 to 2, default 1), top_p (0 to 1, default 1), max_tokens (up to 65536), stop sequences, frequency_penalty, presence_penalty, and stream. For multimodal requests, you can pass images as base64 data URLs or public URLs. Video inputs may require specific encoding—check OrcaRouter documentation. Additional parameters like seed for reproducibility may be supported but are not guaranteed. The model does not support function calling or tools natively; however, you can simulate tool calls by instructing the model in the system prompt. For parallel tool calling, you would need to manage the loop externally. Streaming is recommended for real-time applications to reduce perceived latency.
If you are used to an OpenAI-compatible API, migration requires changing only the base URL and model ID. Replace your existing endpoint with https://api.orcarouter.ai/v1 and set model to "qwen/qwen3.6-35b-a3b". Authentication uses an API key provided by OrcaRouter (set in the Authorization header as Bearer). Rate limits and billing are managed by OrcaRouter. For multimodal migration, ensure your image/video formatting matches the expected schema (OpenAI-compatible). The response format is identical to OpenAI's chat completions, so your existing parsing code should work with minimal changes. Test with a single request to confirm token counting and latency are acceptable.
Yes, the model supports streaming via the OpenAI-compatible server-sent events (SSE) protocol. Set "stream": true in your request. The stream will emit delta tokens as they are generated, exactly as with OpenAI's streaming, including finish_reason and usage information in the final event. Streaming is useful for interactive applications where you want to display output incrementally. Note that streaming does not reduce total token costs; you are billed for the full output. The MoE architecture may produce tokens at a consistent rate, but actual throughput depends on network and server load. Test your integration to ensure proper handling of stream events.
Compared to Mixtral 8x7B (a popular MoE model with 47B total, 12.9B active), Qwen3.6 35B A3B has fewer total parameters but also fewer active parameters (3B vs 12.9B). This makes it potentially more cost-efficient per token. The context window of 262K tokens is significantly larger than Mixtral's default 32K (though Mixtral can be extended). Qwen3.6 A3B also supports image and video input, which Mixtral does not natively. On benchmarks, Mixtral scores around 65-70 on τ²-Bench? Not provided; but Qwen's 95.3 is very high for that specific benchmark. For short-context, pure text tasks, Mixtral may perform comparably or better in some reasoning tasks due to more active parameters. For long-context and multimodal tasks, Qwen3.6 A3B has a clear advantage.
A dense 35B parameter model would require approximately 12 times more compute per token than the 3B active parameters in this MoE model. Qwen3.6 A3B thus offers a speed and cost advantage at inference time, at the potential expense of some consistency because the expert routing may not always activate the most relevant experts for every input. Dense models often achieve more predictable quality across diverse tasks. However, the τ²-Bench score suggests that this MoE model can compete with dense models on long-context reasoning. If you have a high-volume production workload where latency and cost are critical, the MoE approach is beneficial. For research requiring deterministic behavior, a dense model might be preferable.
Choose Qwen3.6 35B A3B when your application requires: (1) processing very long documents (up to 262K tokens) in a single pass, (2) multimodal understanding that includes images and video, (3) strong performance on tasks that involve retrieving and reasoning over large contexts (as measured by τ²-Bench), and (4) cost efficiency from a low-active-parameter MoE architecture. If your tasks are short-form, text-only, and do not require long context, a cheaper model like a 7B dense model may suffice. For tasks requiring the highest possible quality on narrow benchmarks (e.g., math competition problems), a larger dense model (e.g., 70B) might outperform.
Alternatives include the dense Qwen2.5 32B or 72B models if you need more consistent quality across all tasks. For multimodal, GPT-4o or Claude 3.5 Sonnet offer broader visual understanding but at higher cost. For very high throughput, a smaller MoE model like Qwen2.5 14B A2B could be cheaper. If you require function calling or tool use with structured outputs, consider models with native function-calling support (e.g., GPT-4 or Claude). The choice ultimately depends on your specific combination of context length, modality, latency tolerance, and budget. Always run your own evaluation using representative examples.
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.6-35b-a3b",
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| Input / 1M tokens | $0.248 |
| Output / 1M tokens | $1.485 |
| Currency | USD |
Estimate based on list price
Estimate only — actual token counts depend on the provider's tokenizer.
GET /api/public/models/qwen/qwen3.6-35b-a3bOpen @misc{orcarouter_qwen3_6_35b_a3b,
title = {Qwen3.6 35B A3B API},
author = {Qwen},
year = {2026},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/qwen/qwen3.6-35b-a3b}
}Qwen. (2026). Qwen3.6 35B A3B API. OrcaRouter. https://www.orcarouter.ai/models/qwen/qwen3.6-35b-a3b