Qwen3-Max-Thinking: Hands-on met het grootste LLM ter wereld

Qwen3-Max-Thinking werd in november 2025 openbaar beschikbaar. Wanneer je de thinking-modus inschakelt, toont het model zijn redenering voordat het antwoordt. Je ziet hoe het werkt bij wiskundeproblemen, logische puzzels en complexe code. Het model heeft meer dan 1 biljoen parameters en kan tot 262k tokens verwerken.

In deze tutorial stel je API-toegang in, test je de thinking-modus op verschillende problemen en bouw je een Streamlit-app die dezelfde prompt door Qwen3-Max-Thinking, GPT-5 en Claude Sonnet 4.5 laat lopen. Je ziet hoe elk model het probleem benadert en wanneer de thinking-modus helpt. Hier is een preview van de app:

Wat is Qwen3-Max-Thinking?

Qwen3 Max Thinking is Alibaba Cloud’s implementatie van het Qwen3-Max-model, gelanceerd op 5 september 2025. De "thinking" in de naam verwijst naar een speciale modus waarin het model zijn stapsgewijze redeneerproces toont voordat het een antwoord geeft.

De prestaties van het model op wiskunde- en redeneerbenchmarks laten zien wat deze functie oplevert. In combinatie met toolgebruik (zoals code-interpreters voor berekeningen) en opgeschaalde test-time compute behaalde het 100% op AIME25, de American Invitational Mathematics Examination die geavanceerde middelbare schoolwiskunde test met meerstapsredenering. Het behaalde ook 100% op HMMT, het Harvard-MIT Math Tournament dat complex probleemoplossen meet. Deze benchmarks testen daadwerkelijke redeneervermogens in plaats van patroonherkenning of memorisatie.

Hoe test-time compute werkt

Test-time compute is hoe het model zijn uitzonderlijke benchmarkprestaties behaalt. In plaats van alleen rekenkracht te gebruiken tijdens training (wanneer het model leert), gebruikt het die ook tijdens inferentie (wanneer je een API-call doet en het model een respons genereert). In combinatie met toolgebruik kan het model zijn redenering verifiëren en zijn werk toetsen aan externe bronnen.

Hoe Qwen3-Max-Thinking zich verhoudt tot GPT-5 en Claude Sonnet 4.5

Hoewel Qwen3 gelijk scoort met GPT-5 en Claude Sonnet 4.5 op bepaalde benchmarks zoals AIME25, verschillen de modellen op andere vlakken. Bij software-engineeringtaken gemeten met SWE-bench Verified leidt Claude met 77,2%, gevolgd door GPT-5 met 72,8% en Qwen3 met 69,6%. GPT-5 biedt het grootste contextvenster met 400k tokens, vergeleken met 262k voor Qwen3 en 200k voor Claude.

Het prijsvoordeel gaat naar Qwen3 met $1,20/$6,00 per miljoen tokens voor input/output, grofweg de helft van de kosten van GPT-5 ($1,25/$10,00) en 2,5 keer goedkoper dan Claude ($3,00/$15,00). De thinking-modus onderscheidt Qwen3 door expliciete redeneerstappen te tonen.

Aangezien het model nog in preview en training is, komen uitgebreide benchmarkresultaten over alle taken beschikbaar zodra Alibaba de definitieve versie uitbrengt.

Toch vertellen benchmarks niet het hele verhaal. Om gevoel te krijgen bij de prestaties bouwen we in een later onderdeel een vergelijkingsapp om het naast GPT-5 en Claude Sonnet 4.5 te leggen.

Qwen3-Max-Thinking API-toegang instellen

Voordat je Qwen3 Max Thinking kunt gebruiken, heb je Python 3.8 of hoger, pip en een creditcard nodig om je te registreren bij Alibaba Cloud. Wanneer je een account aanmaakt, krijg je een gratis gebruikslimiet, maar je moet wel betalingsgegevens opgeven.

Registreer bij Alibaba Cloud en activeer Model Studio

Ga naar Alibaba Cloud en maak een account aan. Tijdens het aanmelden kies je tussen twee regio’s: International (Singapore) of China (Beijing). De meeste lezers buiten vasteland-China kiezen het best de International-regio.

Deze keuze is belangrijk omdat elke regio zijn eigen API-endpoint en -sleutel heeft die niet uitwisselbaar zijn.

Ga na registratie in de console naar Model Studio. Je moet de dienst activeren voordat je API-sleutels kunt genereren. De Qwen (Alibaba Cloud) tutorial doorloopt het volledige accountinstelproces als je meer gedetailleerde screenshots en uitleg wilt.

Maak en beveilig je API-sleutel

Zodra Model Studio is geactiveerd, ga je in de console naar de sectie API Keys. Genereer een nieuwe sleutel en kopieer deze direct. Alibaba Cloud toont de sleutel maar één keer.

Sla je sleutel op in een .env-bestand om deze gescheiden te houden van je code, en voeg dit bestand toe aan .gitignore om te voorkomen dat je per ongeluk je API-sleutel in versiebeheer commit.

Installeer Python-packages en configureer de omgeving

Qwen3 Max Thinking gebruikt een OpenAI-compatibele API, dus je kunt de standaard OpenAI Python SDK gebruiken. Installeer die samen met python-dotenv voor het beheer van omgevingsvariabelen:

pip install openai python-dotenvMogelijk gemaakt door

Maak een .env-bestand in je projectmap:

DASHSCOPE_API_KEY=your_key_hereMogelijk gemaakt door

Vervang your_key_here door je API-sleutel. Schrijf nu een snelle testscript om te controleren of alles werkt:

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
   api_key=os.getenv("DASHSCOPE_API_KEY"),
   base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
)

completion = client.chat.completions.create(
   model="qwen3-max-preview",
   messages=[{"role": "user", "content": "Say hello in one sentence."}]
)

print(completion.choices[0].message.content)Mogelijk gemaakt door

Voer dit script uit. Als je een fout ziet over ongeldige API-sleutels, controleer dan of je de sleutel correct hebt gekopieerd en of je de juiste base-URL voor je regio gebruikt.

Als het script zonder fouten draait, krijg je een output zoals hieronder:

Hello! How can I assist you today?Mogelijk gemaakt door

De Qwen3-Max Thinking-modus begrijpen

Je hebt zojuist een basis-API-call gemaakt. Schakel nu de thinking-modus in om te zien hoe het model problemen stap voor stap doorloopt.

Thinking-modus inschakelen met extra_body

Om de thinking-modus aan te zetten, voeg je enable_thinking: True toe binnen de parameter extra_body. Hier is een voorbeeld met een prompt die goed werkt met stapsgewijze redenering:

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
   api_key=os.getenv("DASHSCOPE_API_KEY"),
   base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
)

completion = client.chat.completions.create(
   model="qwen3-max-preview",
   messages=[
       {"role": "user", "content": "If I have 3 apples and buy 2 more packs of 4 apples each, then give away half, how many do I have left?"}
   ],
   extra_body={"enable_thinking": True}
)

print("Reasoning:", completion.choices[0].message.reasoning_content)
print("\nFinal answer:", completion.choices[0].message.content)Mogelijk gemaakt door

De respons heeft twee delen. Het veld reasoning_content toont het interne denkproces van het model, waarin het het probleem stap voor stap uitwerkt. Het veld content geeft je het uiteindelijke antwoord. Als de thinking-modus is uitgeschakeld, retourneert reasoning_content None.

Zo ziet de output eruit (redenering ingekort):

Reasoning: The problem: "If I have 3 apples and buy 2 more packs of 4 apples each, then give away half, how many do I have left?" Starting with 3 apples. Then buy 2 packs of 4 apples each: that's 2 * 4 = 8 apples. So total after buying is 3 + 8 = 11 apples. Then give away half: half of 11 is 5.5 apples...

Final answer:
1. Start with: 3 apples.
2. Buy 2 packs of 4 apples each → 2 × 4 = 8 apples.
3. Total after buying: 3 + 8 = 11 apples.
4. Give away half: 11/2 = 5.5 apples.

Answer: You have 5½ apples left.Mogelijk gemaakt door

Kosten beheersen met thinking_budget

Omdat redenering extra tokens gebruikt, kun je de kosten beheersen met de parameter thinking_budget. Voeg deze toe aan extra_body naast enable_thinking:

completion = client.chat.completions.create(
   model="qwen3-max-preview",
   messages=[
       {"role": "user", "content": "Explain why 0.1 + 0.2 doesn't equal 0.3 in Python."}
   ],
   extra_body={
       "enable_thinking": True,
       "thinking_budget": 1000
   }
)Mogelijk gemaakt door

De parameter thinking_budget stelt het maximum aantal tokens in dat het model voor redenering mag gebruiken. Voor eenvoudige problemen werkt 500–1000 tokens. Complexe meerstapsredenering kan 2000–5000 tokens nodig hebben. Als het model de budgetlimiet bereikt, stopt het het redeneerproces en geeft het een eindantwoord op basis van de tot dat moment voltooide redenering.

Je hebt nu gewerkt met de thinking-modus van Qwen3. GPT-5 en Claude hebben ook reasoning-features met een andere syntaxis en aanpak. Om te zien hoe deze modellen zich verhouden, bouwen we een app die alle drie naast elkaar test.

Een chatapp bouwen voor vergelijking van meerdere modellen

Je bouwt een Streamlit-app die dezelfde prompt tegelijkertijd naar Qwen3 Max Thinking, GPT-5 en Claude Sonnet 4.5 stuurt. De app toont alle drie de reacties naast elkaar zodat je kunt vergelijken hoe elk model problemen doorredeneert.

Je kunt de volledige projectcode bekijken in deze GitHub Gist. 

Let op: de volgende secties geven een gedetailleerde uiteenzetting van dat script, dus als je alleen de resultaten van de app wilt, sla dan de volgende sectie helemaal over. De scriptuitleg is educatief bedoeld en laat zien hoe je soortgelijke LLM-gebaseerde applicaties met een Streamlit-UI structureert. 

Stap 1: Projectsetup en afhankelijkheden

Installeer Streamlit voor de webinterface en de SDK van Anthropic voor Claude. Je hebt de OpenAI SDK al vanuit het API-setupgedeelte.

pip install streamlit anthropicMogelijk gemaakt door

Maak een nieuw bestand met de naam model_comparison_chat.py met de imports en omgevingssetup:

import os
import time
from typing import Dict, List
from concurrent.futures import ThreadPoolExecutor, as_completed
from dotenv import load_dotenv
import streamlit as st
from openai import OpenAI
from anthropic import Anthropic

load_dotenv()Mogelijk gemaakt door

Stap 2: API-verbindingen configureren

Je hebt Qwen3 al ingesteld in Sectie 3. Voeg nu GPT-5- en Claude-API-sleutels toe aan je .env-bestand:

DASHSCOPE_API_KEY=your_alibaba_cloud_key
OPENAI_API_KEY=your_openai_key
ANTHROPIC_API_KEY=your_anthropic_keyMogelijk gemaakt door

Voor GPT-5-toegang en prijsdetails, zie de GPT-5-gids. Voor Claude Sonnet 4.5, bekijk het overzicht van Claude Sonnet 4.5.

Initialiseer alle drie de API-clients:

QWEN_CLIENT = OpenAI(
   api_key=os.getenv("DASHSCOPE_API_KEY"),
   base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
)
GPT_CLIENT = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
CLAUDE_CLIENT = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))Mogelijk gemaakt door

Stap 3: Helperfuncties voor elk model maken

In plaats van aparte functies voor elke API te schrijven, gebruik je één uniforme functie die alle drie de modellen afhandelt. Hier is het begin van de functie voor Qwen3:

def call_model(model_name: str, messages: List[Dict], **kwargs) -> Dict:
   """Call any model with unified interface."""
   try:
       start_time = time.time()

       if model_name == "Qwen3 Max Thinking":
           enable_thinking = kwargs.get("enable_thinking", True)
           extra_body = {"enable_thinking": enable_thinking}

           completion = QWEN_CLIENT.chat.completions.create(
               model="qwen3-max-preview",
               messages=messages,
               extra_body=extra_body
           )
           reasoning_content = getattr(
               completion.choices[0].message,
               'reasoning_content',
               None
           )
           # Extract content and token info, then continue belowMogelijk gemaakt door

GPT-5 werkt anders en gebruikt de responses-API met instelbare niveaus voor reasoning-inspanning (vervolg van dezelfde functie):

       elif model_name == "GPT-5":
           reasoning_effort = kwargs.get("reasoning_effort", "medium")

           response = GPT_CLIENT.responses.create(
               model="gpt-5",
               input=messages,
               reasoning={
                   "effort": reasoning_effort,
                   "summary": "auto"
               }
           )
           # Extract response data, then continue belowMogelijk gemaakt door

GPT-5 heeft vier niveaus van reasoning-inspanning: minimal, low, medium en high. Meer inspanning betekent betere kwaliteit maar langzamere reacties en hogere kosten.

Claude Sonnet 4.5 pakt het weer anders aan (vervolg van dezelfde functie):

       else:  # Claude Sonnet 4.5
           enable_thinking = kwargs.get("enable_thinking", True)
           params = {
               "model": "claude-sonnet-4-5",
               "max_tokens": 10000,
               "messages": messages
           }
           if enable_thinking:
               params["thinking"] = {
                   "type": "enabled",
                   "budget_tokens": 5000
               }

           message = CLAUDE_CLIENT.messages.create(**params)
           # Parse thinking blocks from response, then continue belowMogelijk gemaakt door

Let op: De thinking-modus van Claude werkt anders dan die van Qwen3. In plaats van een apart reasoning_content bevat Claude thinking-blokken in de content van de respons die je moet parsen. Dit is een belangrijk verschil bij het vergelijken van de modellen.

Alle drie de modelvertakkingen komen samen om dezelfde structuur te retourneren (einde van de functie):

    return {
               "content": content_text,
               "reasoning_content": thinking_text,
               "response_time": time.time() - start_time,
               "tokens_used": {
                   "input": input_tokens,
                   "output": output_tokens,
                   "total": total_tokens
               },
               "error": None
           }

   except Exception as e:
       return {
           "content": None,
           "reasoning_content": None,
           "response_time": 0,
           "tokens_used": {"input": 0, "output": 0, "total": 0},
           "error": f"{model_name} Error: {str(e)}"
       }Mogelijk gemaakt door

Dit gestandaardiseerde retourformaat maakt het eenvoudig om reacties van elk model met dezelfde code weer te geven.

Stap 4: De Streamlit-interface bouwen

Nu je begrijpt hoe de API van elk model werkt, maak je de webinterface. Begin met de basisconfiguratie van de Streamlit-pagina:

def main():
   st.set_page_config(
       page_title="Multi-Model Comparison Chat",
       page_icon="🤖",
       layout="wide",
       initial_sidebar_state="expanded"
   )

   st.session_state.setdefault("messages", [])
   st.session_state.setdefault("model_responses", [])Mogelijk gemaakt door

Session state bewaart de gespreksgeschiedenis en modelreacties over reruns heen (wanneer Streamlit de pagina ververst na gebruikersinteracties).

Voeg de titel en zijbalkbesturingselementen toe voor de configuratie van de thinking-modus:

st.title("🤖 Multi-Model Comparison Chat")
   st.markdown("""
   Compare **Qwen3 Max Thinking**, **GPT-5**, and **Claude Sonnet 4.5** side-by-side.
   All three models support reasoning modes - see how they approach problems differently.
   """)

   with st.sidebar:
       st.header("⚙️ Settings")

       st.subheader("Thinking Mode")
       qwen_thinking = st.checkbox("Enable Qwen3 Thinking", value=True)
       gpt5_reasoning = st.selectbox(
           "GPT-5 Reasoning Effort",
           options=["minimal", "low", "medium", "high"],
           index=2
       )
       claude_thinking = st.checkbox("Enable Claude Thinking", value=True)Mogelijk gemaakt door

Voeg API-statusindicatoren toe:

st.subheader("API Status")
       st.markdown(f"""
       - Qwen3: {"✅" if os.getenv("DASHSCOPE_API_KEY") else "❌"}
       - GPT-5: {"✅" if os.getenv("OPENAI_API_KEY") else "❌"}
       - Claude: {"✅" if os.getenv("ANTHROPIC_API_KEY") else "❌"}
       """)Mogelijk gemaakt door

Dit toont welke API-sleutels zijn geconfigureerd. Als je rode kruisjes ziet, controleer dan je .env-bestand.

Stap 5: De vergelijkingslogica implementeren

def call_models_parallel(messages: List[Dict], selected_models: List[str], qwen_thinking: bool, gpt5_reasoning: str, claude_thinking: bool) -> Dict[str, Dict]:
   """Call multiple models in parallel."""
   model_kwargs = {
       "Qwen3 Max Thinking": {"enable_thinking": qwen_thinking},
       "GPT-5": {"reasoning_effort": gpt5_reasoning},
       "Claude Sonnet 4.5": {"enable_thinking": claude_thinking}
   }

   with ThreadPoolExecutor(max_workers=3) as executor:
       futures = {
           executor.submit(call_model, m, messages, **model_kwargs[m]): m
           for m in selected_models if m in model_kwargs
       }
       return {futures[f]: f.result() for f in as_completed(futures)}Mogelijk gemaakt door

In plaats van te wachten tot elk model sequentieel antwoordt, roept parallelle uitvoering alle drie tegelijk aan, waardoor de totale wachttijd afneemt.

Integreer dit in je chatinterface en toon reacties naast elkaar:

if prompt := st.chat_input("Ask a question to all models..."):
       st.session_state.messages.append({"role": "user", "content": prompt})

       with st.spinner("🤔 Models are thinking..."):
           responses = call_models_parallel(
               st.session_state.messages,
               ["Qwen3 Max Thinking", "GPT-5", "Claude Sonnet 4.5"],
               qwen_thinking,
               gpt5_reasoning,
               claude_thinking
           )

       cols = st.columns(3)
       for idx, (model_name, response_data) in enumerate(responses.items()):
           with cols[idx]:
               st.markdown(f"### {model_name}")
               if response_data["reasoning_content"]:
                   with st.expander("🧠 Thinking Process", expanded=False):
                       st.markdown(response_data["reasoning_content"])
               st.markdown(response_data["content"])Mogelijk gemaakt door

Dit creëert drie kolommen, één voor elk model. Het denkproces blijft standaard ingeklapt, zodat gebruikers zich kunnen focussen op de eindantwoorden.

Stap 6: Testen en verfijnen

Start de app met:

streamlit run model_comparison_chat.pyMogelijk gemaakt door

Begin met een eenvoudige sanity check-vraag zoals “Wat is 2+2?” om te bevestigen dat je API-verbindingen werken en parallelle uitvoering functioneert.

Zodra je bevestigt dat de basisfunctionaliteit werkt, ben je klaar om de modellen te testen met complexe prompts die hun verschillende redeneeraanpakken onthullen.

De app testen met complexe prompts

Test met de vergelijkingsapp moeilijkere problemen. Probeer deze prompts in je app om te zien hoe de verschillende modellen ze benaderen.

De testprompts

Hier zijn drie prompts die duidelijke patronen laten zien in hoe elk model denkt.

Test 1: Geavanceerd wiskundig redeneren

Een ronde pizza wordt in 8 gelijke punten gesneden. Alice eet 3 punten, daarna eet Bob de helft van wat over is. Vervolgens neemt Charlie 1 punt, en tot slot eet Dana 40% van de resterende punten. Hoeveel punten blijven er over? En als de oorspronkelijke pizza een diameter van 16 inch had, wat is dan de totale oppervlakte (in vierkante inches) van de pizza die is geconsumeerd?

Test 2: Meerstaps logische redenering

Vijf vrienden — Amy, Ben, Clara, David en Emma — zitten in een rij in een

bioscoop. Aan de volgende voorwaarden moet worden voldaan:

1. Amy moet naast Ben zitten

2. Clara mag niet naast David zitten

3. Emma moet op een van de uiteinden zitten

4. Ben mag niet aan een van de uiteinden zitten. Gegeven deze beperkingen, geef alle mogelijke zitopstellingen van links naar rechts.

Test 3: Codegeneratie met beperkingen

Schrijf een Python-functie die de langste palindromische substring in een gegeven string vindt, maar met deze specifieke vereisten:

1. Tijdcomplexiteit moet O(n²) of beter zijn

2. Moet Unicode-tekens correct afhandelen

3. Moet de eerste voorkoming retourneren als er meerdere palindromen van dezelfde lengte zijn

4. Inclusief gedetailleerde docstring met voorbeelden

5. Voeg type hints toe

6. Behandel randgevallen (lege string, enkel teken, geen palindromen).

Leg ook je algoritmekeuze uit

en waarom het aan de complexiteitseis voldoet.

Resultaten

Alle drie de modellen hadden elk probleem goed. Zo presteerden ze:

Qwen3 duurt 10x langer dan Claude en gebruikt 3–4x meer tokens.

De aanpak van Qwen3

Het overweegt alles. Bij het pizzaprobleem stelde het de vraag of fracties van punten logisch zijn, overwoog of de wiskunde naar hele getallen moet afronden, valideerde berekeningen meerdere keren en bekeek alternatieve interpretaties voordat het een antwoord gaf. 

Je ziet het denken “wat als dit” en “maar misschien dat” overal terug. Voor het zitprobleem werkte het uit: “als Ben hier zit, waar kan Amy dan heen” voor elke mogelijkheid. 

De palindrome-oplossing ging gepaard met een diepgaande analyse van waarom het dat algoritme boven alternatieven koos, hoe het Unicode-randgevallen afhandelt en grondige complexiteitsuitwerkingen. Het is alsof je iemand hardop ziet nadenken en zijn werk herhaaldelijk controleren.

De aanpak van GPT-5

Het is gestructureerd en methodisch. Het zette elk probleem uiteen, werkte de stappen op volgorde af en verifieerde resultaten. Minder exploratie, meer uitvoering. 

Bij de zitpuzzel plaatste het eerst Emma aan een uiteinde en vulde daarna posities terwijl het de regels controleerde. 

De palindrome-code kwam met duidelijke redenering over de algoritmekeuze en degelijke documentatie. Het volgt een plan zonder veel terug te krabbelen. Je krijgt genoeg detail om het denkproces te begrijpen, maar het twijfelt niet voortdurend aan zichzelf.

De aanpak van Claude 

Het gaat snel. Het ziet het oplossingspad snel en voert het strak uit. Voor het zitprobleem ordende het per geval (Emma op positie 1 versus positie 5) en werkte elk uit. De palindrome-code was schoon en goed gedocumenteerd, maar kwam sneller ter zake. Het laat zijn werk zien maar blijft beknopt.

De praktische conclusie: gebruik Qwen3 wanneer je elke overweging die tot een oplossing leidde wilt zien. De gedetailleerde denkwijze helpt wanneer je van het model wilt leren of complexe beslissingen wilt valideren. Gebruik Claude wanneer snelheid telt en je erop vertrouwt dat het antwoord goed is zonder elke stap te tonen. Gebruik GPT-5 wanneer je iets tussen die uitersten wilt.

Let op: Deze tests vatten niet alle mogelijkheden van de drie modellen volledig. Je resultaten kunnen variëren met andere prompts.

Conclusie

In deze tutorial heb ik laten zien hoe je Qwen3 Max Thinking instelt, de thinking-modus getest met verschillende soorten problemen en een vergelijkingsapp gebouwd die prompts naast elkaar door Qwen3, GPT-5 en Claude Sonnet 4.5 laat lopen. 

De kerninzichten: elk model heeft sterke punten voor verschillende scenario’s. Qwen3 blinkt uit wanneer je gedetailleerde redenering nodig hebt en elke stap wilt begrijpen. Claude wint op snelheid en strakke uitvoering. GPT-5 balanceert beide benaderingen.

Gebruik je vergelijkingsapp om deze modellen met je eigen problemen te testen. Terwijl je met verschillende taken experimenteert, ontwikkel je een gevoel voor welk model het beste werkt voor jouw behoeften.

Wil je dieper duiken in Qwen3 en multi-modelontwikkeling, bekijk dan de OpenRouter-tutorial voor het beheren van meerdere model-API’s, of leer hoe je kleinere Qwen3-modellen lokaal draait met Ollama voor offline ontwikkeling.