Qwen3-32B-FP8 is the official FP8 checkpoint of the dense Qwen3-32B language model. The manufacturer describes mathematics, logical reasoning, code generation, creative writing, role-based dialogue and instruction following across multiple turns. The family supports more than 100 languages and dialects. The input and output are text, and this same release provides both thinking and direct-response behavior.
This model has 32.8 billion parameters, including 31.2 billion outside embeddings, and 64 layers. Its grouped-query attention contains 64 query heads and eight key/value heads. It is a dense architecture, distinct from Qwen3’s mixture-of-experts releases with total and activated parameter counts. FP8 is also part of the exact edition identity. For a development assistant, give a function, a specification and several inputs, then request an explanation of current behavior and a revised implementation that preserves the agreed interface. For an editorial task, provide the actual source, intended reader and terminology instead of relying on an unspecified background.
The manufacturer’s quickstart uses the designated chat template. Separate the task from the supplied materials and specify the final shape. A useful analysis request could compare two data-validation approaches using the same field rules, identify the cases each accepts and return a proposed validation function. Include missing-value rules, representative data and the required error messages. For multilingual content, give a glossary and ask for a translation plus a list of terms requiring review. Such preparation makes the generated result checkable against a concrete input. The published integration expects a Qwen3-aware runtime; the card warns that Transformers versions below 4.51.0 do not recognize the required architecture.
The FP8 note describes fine-grained quantization with block size 128. The checkpoint configuration also identifies its FP8 quantization setup. The manufacturer lists Transformers, SGLang and vLLM for inference, but flags a distributed-inference issue with fine-grained FP8 in Transformers and notes that multi-device use may need CUDA_LAUNCH_BLOCKING=1. Keep this compatibility caveat separate from the text capabilities. The quantized identity does not by itself establish a measured latency, hardware saving or equivalence of responses to the original checkpoint.
Thinking is enabled by default in the provided template. A hard non-thinking setting suppresses its reasoning section. When thinking stays enabled, /think and /no_think are soft controls for successive turns, with the latest instruction applying; they cannot override a hard disable. Ask for reasoning when the model must examine contradictory conditions, then use a direct follow-up to present the accepted result in a concise format. Keep the final response separate and use the final response, rather than prior reasoning, as history for later turns. With thinking enabled, even a soft non-thinking request retains a reasoning block; its content may be empty. The hard disable removes that block.
The card includes agentic use and recommends Qwen-Agent for tool formatting and parsing. An application supplies the tool definitions, checks calls, executes them and returns results. In the validation example, a controlled test runner could evaluate proposed code against the supplied cases. Ask the model to summarize actual pass/fail results and revise a named failing condition. Its output should not treat a proposed invocation as evidence of execution. Decide the tool’s permitted scope and output fields before beginning that workflow. The Qwen3 guide also describes parallel and multi-step tool calls, with arguments represented as objects and results supplied back into the conversation.
The exact card lists 32,768 native context tokens and 131,072 with YaRN. Expansion depends on configuration; static scaling can affect shorter texts. Both the input and generated result occupy the sequence budget. Label long source sections and allocate enough space for the required code and explanation. The published output examples and recommended lengths do not establish a universal hard output cap. For longer generation, evaluate whether the result remains coherent and meets the task’s requirements. The Qwen3 documentation discusses assistant-message lengths of 38,912 tokens in thinking mode and 16,384 in non-thinking mode in its training-length explanation, and recommends evaluating the quality of longer generation. These figures are distinct from the overall context window and are not an endpoint-specific hard cap. The card also explains its default positional allocation of 40,960 tokens as 8,192 for typical prompts plus 32,768 for output; this is manufacturer configuration guidance, separate from the native training context and any endpoint limit.
The recommended sampling settings are temperature 0.6, top-p 0.95, top-k 20 and min-p 0 for thinking, and 0.7, 0.8, 20 and 0 for direct mode. The manufacturer warns against greedy reasoning because of repetition; high presence penalties can sometimes mix languages. Require a final answer that can be inspected, such as a decision table, the completed function and a case list. Validate returned structured fields, check calculations against the source and run code in the intended environment, retaining this exact FP8 identity when recording the results.
", "aboutText": "Qwen3-32B-FP8 is the official FP8 checkpoint of the dense Qwen3-32B language model. The manufacturer describes mathematics, logical reasoning, code generation, creative writing, role-based dialogue and instruction following across multiple turns. The family supports more than 100 languages and dialects. The input and output are text, and this same release provides both thinking and direct-response behavior.\n\nThis model has 32.8 billion parameters, including 31.2 billion outside embeddings, and 64 layers. Its grouped-query attention contains 64 query heads and eight key/value heads. It is a dense architecture, distinct from Qwen3’s mixture-of-experts releases with total and activated parameter counts. FP8 is also part of the exact edition identity. For a development assistant, give a function, a specification and several inputs, then request an explanation of current behavior and a revised implementation that preserves the agreed interface. For an editorial task, provide the actual source, intended reader and terminology instead of relying on an unspecified background.\n\nThe manufacturer’s quickstart uses the designated chat template. Separate the task from the supplied materials and specify the final shape. A useful analysis request could compare two data-validation approaches using the same field rules, identify the cases each accepts and return a proposed validation function. Include missing-value rules, representative data and the required error messages. For multilingual content, give a glossary and ask for a translation plus a list of terms requiring review. Such preparation makes the generated result checkable against a concrete input. The published integration expects a Qwen3-aware runtime; the card warns that Transformers versions below 4.51.0 do not recognize the required architecture.\n\nThe FP8 note describes fine-grained quantization with block size 128. The checkpoint configuration also identifies its FP8 quantization setup. The manufacturer lists Transformers, SGLang and vLLM for inference, but flags a distributed-inference issue with fine-grained FP8 in Transformers and notes that multi-device use may need CUDA_LAUNCH_BLOCKING=1. Keep this compatibility caveat separate from the text capabilities. The quantized identity does not by itself establish a measured latency, hardware saving or equivalence of responses to the original checkpoint.\n\nThinking is enabled by default in the provided template. A hard non-thinking setting suppresses its reasoning section. When thinking stays enabled, /think and /no_think are soft controls for successive turns, with the latest instruction applying; they cannot override a hard disable. Ask for reasoning when the model must examine contradictory conditions, then use a direct follow-up to present the accepted result in a concise format. Keep the final response separate and use the final response, rather than prior reasoning, as history for later turns. With thinking enabled, even a soft non-thinking request retains a reasoning block; its content may be empty. The hard disable removes that block.\n\nThe card includes agentic use and recommends Qwen-Agent for tool formatting and parsing. An application supplies the tool definitions, checks calls, executes them and returns results. In the validation example, a controlled test runner could evaluate proposed code against the supplied cases. Ask the model to summarize actual pass/fail results and revise a named failing condition. Its output should not treat a proposed invocation as evidence of execution. Decide the tool’s permitted scope and output fields before beginning that workflow. The Qwen3 guide also describes parallel and multi-step tool calls, with arguments represented as objects and results supplied back into the conversation.\n\nThe exact card lists 32,768 native context tokens and 131,072 with YaRN. Expansion depends on configuration; static scaling can affect shorter texts. Both the input and generated result occupy the sequence budget. Label long source sections and allocate enough space for the required code and explanation. The published output examples and recommended lengths do not establish a universal hard output cap. For longer generation, evaluate whether the result remains coherent and meets the task’s requirements. The Qwen3 documentation discusses assistant-message lengths of 38,912 tokens in thinking mode and 16,384 in non-thinking mode in its training-length explanation, and recommends evaluating the quality of longer generation. These figures are distinct from the overall context window and are not an endpoint-specific hard cap. The card also explains its default positional allocation of 40,960 tokens as 8,192 for typical prompts plus 32,768 for output; this is manufacturer configuration guidance, separate from the native training context and any endpoint limit.\n\nThe recommended sampling settings are temperature 0.6, top-p 0.95, top-k 20 and min-p 0 for thinking, and 0.7, 0.8, 20 and 0 for direct mode. The manufacturer warns against greedy reasoning because of repetition; high presence penalties can sometimes mix languages. Require a final answer that can be inspected, such as a decision table, the completed function and a case list. Validate returned structured fields, check calculations against the source and run code in the intended environment, retaining this exact FP8 identity when recording the results.", "editorialOverlay": { "copy_fields": { "practical_html": "Technical example in English
Compare missing-value validators\n\nCompare two Python validators for an optional quantity: A uses if not value: return None; B uses if value is None: return None. Requirement: None means omitted, integer zero is valid, and negative quantities are invalid. Explain each validator's behavior for None, 0 and -1, then propose a complete function with explicit validation errors.A three-input comparison table and a proposed function implementing the supplied rules.Check zero is preserved rather than treated as missing, and negatives are rejected explicitly.qwen/qwen3-32b-fp8Qwen3-32B-FP8 is the fine-grained FP8 edition of Qwen3’s 32.8-billion-parameter dense text model. It combines direct and thinking responses for multilingual writing, code and analysis, with separate checkpoint and compatibility details.
This description covers the model’s capabilities. Available in Ailoot inputs, outputs and options are listed for the selected method below.
Qwen3-32B-FP8 is the official FP8 checkpoint of the dense Qwen3-32B language model. The manufacturer describes mathematics, logical reasoning, code generation, creative writing, role-based dialogue and instruction following across multiple turns. The family supports more than 100 languages and dialects. The input and output are text, and this same release provides both thinking and direct-response behavior.
This model has 32.8 billion parameters, including 31.2 billion outside embeddings, and 64 layers. Its grouped-query attention contains 64 query heads and eight key/value heads. It is a dense architecture, distinct from Qwen3’s mixture-of-experts releases with total and activated parameter counts. FP8 is also part of the exact edition identity. For a development assistant, give a function, a specification and several inputs, then request an explanation of current behavior and a revised implementation that preserves the agreed interface. For an editorial task, provide the actual source, intended reader and terminology instead of relying on an unspecified background.
The manufacturer’s quickstart uses the designated chat template. Separate the task from the supplied materials and specify the final shape. A useful analysis request could compare two data-validation approaches using the same field rules, identify the cases each accepts and return a proposed validation function. Include missing-value rules, representative data and the required error messages. For multilingual content, give a glossary and ask for a translation plus a list of terms requiring review. Such preparation makes the generated result checkable against a concrete input. The published integration expects a Qwen3-aware runtime; the card warns that Transformers versions below 4.51.0 do not recognize the required architecture.
The FP8 note describes fine-grained quantization with block size 128. The checkpoint configuration also identifies its FP8 quantization setup. The manufacturer lists Transformers, SGLang and vLLM for inference, but flags a distributed-inference issue with fine-grained FP8 in Transformers and notes that multi-device use may need CUDA_LAUNCH_BLOCKING=1. Keep this compatibility caveat separate from the text capabilities. The quantized identity does not by itself establish a measured latency, hardware saving or equivalence of responses to the original checkpoint.
Thinking is enabled by default in the provided template. A hard non-thinking setting suppresses its reasoning section. When thinking stays enabled, /think and /no_think are soft controls for successive turns, with the latest instruction applying; they cannot override a hard disable. Ask for reasoning when the model must examine contradictory conditions, then use a direct follow-up to present the accepted result in a concise format. Keep the final response separate and use the final response, rather than prior reasoning, as history for later turns. With thinking enabled, even a soft non-thinking request retains a reasoning block; its content may be empty. The hard disable removes that block.
The card includes agentic use and recommends Qwen-Agent for tool formatting and parsing. An application supplies the tool definitions, checks calls, executes them and returns results. In the validation example, a controlled test runner could evaluate proposed code against the supplied cases. Ask the model to summarize actual pass/fail results and revise a named failing condition. Its output should not treat a proposed invocation as evidence of execution. Decide the tool’s permitted scope and output fields before beginning that workflow. The Qwen3 guide also describes parallel and multi-step tool calls, with arguments represented as objects and results supplied back into the conversation.
The exact card lists 32,768 native context tokens and 131,072 with YaRN. Expansion depends on configuration; static scaling can affect shorter texts. Both the input and generated result occupy the sequence budget. Label long source sections and allocate enough space for the required code and explanation. The published output examples and recommended lengths do not establish a universal hard output cap. For longer generation, evaluate whether the result remains coherent and meets the task’s requirements. The Qwen3 documentation discusses assistant-message lengths of 38,912 tokens in thinking mode and 16,384 in non-thinking mode in its training-length explanation, and recommends evaluating the quality of longer generation. These figures are distinct from the overall context window and are not an endpoint-specific hard cap. The card also explains its default positional allocation of 40,960 tokens as 8,192 for typical prompts plus 32,768 for output; this is manufacturer configuration guidance, separate from the native training context and any endpoint limit.
The recommended sampling settings are temperature 0.6, top-p 0.95, top-k 20 and min-p 0 for thinking, and 0.7, 0.8, 20 and 0 for direct mode. The manufacturer warns against greedy reasoning because of repetition; high presence penalties can sometimes mix languages. Require a final answer that can be inspected, such as a decision table, the completed function and a case list. Validate returned structured fields, check calculations against the source and run code in the intended environment, retaining this exact FP8 identity when recording the results.
POST /v1/chat/completionstexttext| Field | Type | Requirement | Values & limits | Default |
|---|---|---|---|---|
Fieldmodel | Typestring | RequirementRequired | Values & limits qwen/qwen3-32b-fp8 | Default— |
Fieldmessages | Typemessage[] | RequirementRequired | Values & limits Minimum items: 1 | Default— |
Fieldmessages[].role | Typestring | RequirementRequired | Values & limits Examples: system, user, assistant, tool, function Conditions: These roles are explicitly represented by Source compatibility types; the exact model role set remains model-specific. Model-specific | Default— |
Fieldmessages[].content | Typestring|content_part[]|null | RequirementOptional | Values & limits | Default— |
Fieldmessages[].tool_calls | Typetool_call[] | RequirementOptional | Values & limits | Default— |
Fieldmessages[].tool_call_id | Typestring | RequirementOptional | Values & limits Applies when: role=tool; use actual returned ID | Default— |
Fieldmessages[].name | Typestring | RequirementOptional | Values & limits | Default— |
Fieldmessages[].reasoning_content | Typestring | RequirementOptional | Values & limits Applies when: Round-trip actual returned reasoning where this model uses it | Default— |
Fieldmessages[].reasoning_details | Typeobject|array | RequirementOptional | Values & limits Model-specific | Default— |
Fieldmax_tokens | Typeinteger | RequirementOptional | Values & limits Minimum: 1 Model-specific | Default— |
Fieldmax_completion_tokens | Typeinteger | RequirementOptional | Values & limits Minimum: 1 Model-specific | Default— |
Fieldstream | Typeboolean | RequirementOptional | Values & limits | Defaultfalse |
Fieldstream_options.include_usage | Typeboolean | RequirementOptional | Values & limits Model-specific | Default— |
Fieldtemperature | Typenumber | RequirementOptional | Values & limits Model-specific | Default— |
Fieldtop_p | Typenumber | RequirementOptional | Values & limits Model-specific | Default— |
Fieldstop | Typestring|string[] | RequirementOptional | Values & limits Model-specific | Default— |
Fieldtools | Typefunction_tool[] | RequirementOptional | Values & limits Model-specific | Default— |
Fieldtools[].type | Typestring | RequirementOptional | Values & limits function Model-specific | Default— |
Fieldtools[].function.name | Typestring | RequirementRequired | Values & limits Applies when: function tool supplied | Default— |
Fieldtools[].function.description | Typestring | RequirementOptional | Values & limits | Default— |
Fieldtools[].function.parameters | TypeJSON_schema | RequirementOptional | Values & limits | Default— |
Fieldtool_choice | Typestring|object | RequirementOptional | Values & limits Model-specific | Default— |
Fieldparallel_tool_calls | Typeboolean | RequirementOptional | Values & limits Model-specific | Default— |
Fieldresponse_format | Typeobject | RequirementOptional | Values & limits Model-specific | Default— |
Fieldreasoning_effort | Typestring | RequirementOptional | Values & limits Model-specific | Default— |
Fieldreasoning | Typeobject | RequirementOptional | Values & limits Model-specific | Default— |
Fieldservice_tier | Typestring | RequirementOptional | Values & limits Model-specific | Default— |
Fieldinstructions | Typestring | RequirementOptional | Values & limits Compatibility field | Default— |
Fieldfunctions | Typefunction[] | RequirementOptional | Values & limits Model-specific | Default— |
Fieldfunction_call | Typestring|object | RequirementOptional | Values & limits Model-specific | Default— |
Fieldprompt_cache_options | Typeobject | RequirementOptional | Values & limits Model-specific | Default— |
Fieldmodalities | Typestring[] | RequirementOptional | Values & limits text | Default— |
Fieldprovider | Typeobject | RequirementOptional | Values & limits Conditions: provider.options is rejected on this Ultra text route | Default— |
Fieldcache_control.ttl | Typestring | RequirementOptional | Values & limits Conditions: 1h is rejected in actual prompt-cache locations | Default— |
Text · UTF8 text
messages[].content
| Parameter | Contract |
|---|---|
Parametercontent_type | Contractapplication/json |
Parameterrequired | Contractmodel, messages |
Parametermaterial_types | Contracttext |
Parametermessages | Contractmessage array with role/content shape |
Parameterfile_material | Contractactual UTF-8 document inserted as literal text; no file ID inferred |
Parameteroptional_controls | Contractstream, temperature, top_p, stop, max_tokens, max_completion_tokens, reasoning, response_format, tools, tool_choice |
Parametercontrol_scope | Contractmodel-specific; user function tools differ from hosted tools |
Parameteroutput_modalities | Contracttext |
Parameterhosted_operations | Contractfalse |
Parametermultimodal_input_binding | Contractnull |
Lifecycle: synchronous_or_streamed
Send exact model ID with messages.
Context length is not an output cap.
A text file may supply literal text; image/audio/file-object inputs need exact binding.
Tariff references do not add request options. Supported parameters are listed for the selected method.
| Configuration | Rate schedule | Charge |
|---|---|---|
| ConfigurationBase token rates | Rate scheduleBase rate | Charge Input · Input tokens $0.0002 / 1K tokens Output · Output tokens $0.001 / 1K tokens Input · Cache read $0 / 1K tokens Input · Cache write $0 / 1K tokens Input · Cache write, 1 hour — / 1K tokens |
Ailoot reserves an estimated amount before a request. After the result, it settles the final charge from measured usage. Streaming settlement uses the final usage record. How reservation and settlement work →
set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"model": "qwen/qwen3-32b-fp8", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}')\n\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \\\n -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\nr=json.loads(Path("result.json").read_text())\nfor x in r.get("choices",[]):\n if x.get("message",{}).get("content"): print(x["message"]["content"])\nPY_RESULT\nfrom openai import OpenAI\nimport os\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nresult=client.chat.completions.create(model='qwen/qwen3-32b-fp8',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}])\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n ext = "png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "jpg" if raw.startswith(b"\\xff\\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(result.to_dict(mode="json"))\nfrom openai import OpenAI\nimport os\nfrom pathlib import Path\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n ext = "png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "jpg" if raw.startswith(b"\\xff\\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nwith client.chat.completions.stream(model='qwen/qwen3-32b-fp8',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:\n with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:\n for event in stream:\n payload=event.to_dict(mode="json")\n log.write(json.dumps(payload,ensure_ascii=False)+"\\n"); log.flush()\n print(json.dumps(payload,ensure_ascii=False))\n final=stream.get_final_completion()\n save_result(final.to_dict(mode="json"),"stream-result")\njson or SSE
Keep every complete returned response, file and content part.
Keep every choice and its content/tool calls/reasoning. In SSE assemble deltas by choice/tool index, retain the final finish reason and usage.
Keep request/response IDs and headers. No generic text job retrieval URL is supplied.
| Field | Type |
|---|---|
Fieldchoices[].index | Typeinteger |
Fieldchoices[].message.content | Typestring|null |
Fieldchoices[].message.tool_calls | Typetool_call[] |
Fieldchoices[].message.reasoning_content | Typestring |
Fieldchoices[].message.reasoning_details | Typeobject|array |
Fieldchoices[].finish_reason | Typestring|null |
Fieldusage | Typeobject |
| Response | Condition | Next step |
|---|---|---|
Response400 · invalid_request_error | ConditionInvalid required fields, material representation or parameter value | Next stepCorrect the indicated fields before a new creation request. |
Ailoot Ultra qwen/qwen3-32b-fp8
Use the method paths shown above.
qwen/qwen3-32b-fp8Qwen3-32B-FP8 is the fine-grained FP8 edition of Qwen3’s 32.8-billion-parameter dense text model. It combines direct and thinking responses for multilingual writing, code and analysis, with separate checkpoint and compatibility details.
This description covers the model’s capabilities. Available in Ailoot inputs, outputs and options are listed for the selected method below.
Qwen3-32B-FP8 is the official FP8 checkpoint of the dense Qwen3-32B language model. The manufacturer describes mathematics, logical reasoning, code generation, creative writing, role-based dialogue and instruction following across multiple turns. The family supports more than 100 languages and dialects. The input and output are text, and this same release provides both thinking and direct-response behavior.
This model has 32.8 billion parameters, including 31.2 billion outside embeddings, and 64 layers. Its grouped-query attention contains 64 query heads and eight key/value heads. It is a dense architecture, distinct from Qwen3’s mixture-of-experts releases with total and activated parameter counts. FP8 is also part of the exact edition identity. For a development assistant, give a function, a specification and several inputs, then request an explanation of current behavior and a revised implementation that preserves the agreed interface. For an editorial task, provide the actual source, intended reader and terminology instead of relying on an unspecified background.
The manufacturer’s quickstart uses the designated chat template. Separate the task from the supplied materials and specify the final shape. A useful analysis request could compare two data-validation approaches using the same field rules, identify the cases each accepts and return a proposed validation function. Include missing-value rules, representative data and the required error messages. For multilingual content, give a glossary and ask for a translation plus a list of terms requiring review. Such preparation makes the generated result checkable against a concrete input. The published integration expects a Qwen3-aware runtime; the card warns that Transformers versions below 4.51.0 do not recognize the required architecture.
The FP8 note describes fine-grained quantization with block size 128. The checkpoint configuration also identifies its FP8 quantization setup. The manufacturer lists Transformers, SGLang and vLLM for inference, but flags a distributed-inference issue with fine-grained FP8 in Transformers and notes that multi-device use may need CUDA_LAUNCH_BLOCKING=1. Keep this compatibility caveat separate from the text capabilities. The quantized identity does not by itself establish a measured latency, hardware saving or equivalence of responses to the original checkpoint.
Thinking is enabled by default in the provided template. A hard non-thinking setting suppresses its reasoning section. When thinking stays enabled, /think and /no_think are soft controls for successive turns, with the latest instruction applying; they cannot override a hard disable. Ask for reasoning when the model must examine contradictory conditions, then use a direct follow-up to present the accepted result in a concise format. Keep the final response separate and use the final response, rather than prior reasoning, as history for later turns. With thinking enabled, even a soft non-thinking request retains a reasoning block; its content may be empty. The hard disable removes that block.
The card includes agentic use and recommends Qwen-Agent for tool formatting and parsing. An application supplies the tool definitions, checks calls, executes them and returns results. In the validation example, a controlled test runner could evaluate proposed code against the supplied cases. Ask the model to summarize actual pass/fail results and revise a named failing condition. Its output should not treat a proposed invocation as evidence of execution. Decide the tool’s permitted scope and output fields before beginning that workflow. The Qwen3 guide also describes parallel and multi-step tool calls, with arguments represented as objects and results supplied back into the conversation.
The exact card lists 32,768 native context tokens and 131,072 with YaRN. Expansion depends on configuration; static scaling can affect shorter texts. Both the input and generated result occupy the sequence budget. Label long source sections and allocate enough space for the required code and explanation. The published output examples and recommended lengths do not establish a universal hard output cap. For longer generation, evaluate whether the result remains coherent and meets the task’s requirements. The Qwen3 documentation discusses assistant-message lengths of 38,912 tokens in thinking mode and 16,384 in non-thinking mode in its training-length explanation, and recommends evaluating the quality of longer generation. These figures are distinct from the overall context window and are not an endpoint-specific hard cap. The card also explains its default positional allocation of 40,960 tokens as 8,192 for typical prompts plus 32,768 for output; this is manufacturer configuration guidance, separate from the native training context and any endpoint limit.
The recommended sampling settings are temperature 0.6, top-p 0.95, top-k 20 and min-p 0 for thinking, and 0.7, 0.8, 20 and 0 for direct mode. The manufacturer warns against greedy reasoning because of repetition; high presence penalties can sometimes mix languages. Require a final answer that can be inspected, such as a decision table, the completed function and a case list. Validate returned structured fields, check calculations against the source and run code in the intended environment, retaining this exact FP8 identity when recording the results.
POST /v1/messagestextjson, sse| Field | Type | Requirement | Values & limits | Default |
|---|---|---|---|---|
Fieldmodel | Typestring | RequirementRequired | Values & limits qwen/qwen3-32b-fp8 | Default— |
Fieldmessages | Typemessage[] | RequirementRequired | Values & limits | Default— |
Fieldmessages[].role | Typestring | RequirementRequired | Values & limits user, assistant | Default— |
Fieldmessages[].content | Typestring | RequirementRequired | Values & limits | Default— |
Fieldmax_tokens | Typeinteger | RequirementRequired | Values & limits | Default— |
Fieldstream | Typeboolean | RequirementOptional | Values & limits | Defaultfalse |
Text · UTF-8 text
messages[].content string
| Parameter | Contract |
|---|---|
Parametercontent_type | Contractapplication/json |
Parameterrequired | Contractmodel, messages, max_tokens |
Parameteroptional_controls | Contractstream |
Parametermaterial_types | Contracttext |
Parametertext_file_material | ContractRead the actual UTF-8 document and put its text in the indicated input or message content string. |
Lifecycle: synchronous_or_streamed
Tariff references do not add request options. Supported parameters are listed for the selected method.
| Configuration | Rate schedule | Charge |
|---|---|---|
| ConfigurationBase token rates | Rate scheduleBase rate | Charge Input · Input tokens $0.0002 / 1K tokens Output · Output tokens $0.001 / 1K tokens Input · Cache read $0 / 1K tokens Input · Cache write $0 / 1K tokens Input · Cache write, 1 hour — / 1K tokens |
Ailoot reserves an estimated amount before a request. After the result, it settles the final charge from measured usage. Streaming settlement uses the final usage record. How reservation and settlement work →
{\n "model": "qwen/qwen3-32b-fp8",\n "max_tokens": 128,\n "messages": [\n {\n "role": "user",\n "content": "Summarize the incident report."\n }\n ],\n "stream": false\n}set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"\nexport AILOOT_TEXT_FILE\npython3 - <<'PY_REQUEST'\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'qwen/qwen3-32b-fp8', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nPath('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \\\n -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nPY_RESULT\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'qwen/qwen3-32b-fp8', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nfrom urllib.request import Request, urlopen\nfrom urllib.error import HTTPError\n\napi_key = os.environ['AILOOT_API_KEY']\nif not api_key.strip():\n raise SystemExit('Set AILOOT_API_KEY before making a request')\nheaders = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}\nheaders['x-api-key'] = api_key\nrequest = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')\ntry:\n with urlopen(request, timeout=120) as response:\n raw = response.read()\n Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')\nexcept HTTPError as error:\n Path('result.json').write_bytes(error.read())\n Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')\n raise\nPath('result.json').write_bytes(raw)\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nJSON or SSE
Keep every complete returned response, file and content part.
Keep all content blocks, thinking signatures and actual tool-use IDs. Assemble all SSE block deltas; a first text block is not the complete output.
Keep request/response IDs and headers. No generic text job retrieval URL is supplied.
| Field | Type |
|---|---|
Fieldid | Typestring |
Fieldmodel | Typestring |
Fieldcontent[] | Typetext|thinking|tool_use|other content block |
Fieldstop_reason | Typestring|null |
Fieldusage | Typeobject |
| Response | Condition | Next step |
|---|---|---|
Response400 · invalid_request_error | ConditionInvalid required fields, material representation or parameter value | Next stepCorrect the indicated fields before a new creation request. |
Ailoot Ultra qwen/qwen3-32b-fp8
Use the method paths shown above.
Technical example in English
Compare missing-value validators\n\nCompare two Python validators for an optional quantity: A uses if not value: return None; B uses if value is None: return None. Requirement: None means omitted, integer zero is valid, and negative quantities are invalid. Explain each validator's behavior for None, 0 and -1, then propose a complete function with explicit validation errors.A three-input comparison table and a proposed function implementing the supplied rules.Check zero is preserved rather than treated as missing, and negatives are rejected explicitly.