• gpt-oss-120b
• LLM-jp-4-thinking
• Gemma 4
• DeepSeek-V3.2
• Qwen3.5
• Kimi K2.5
• Phi-4-reasoning
• GLM-5
• Mistral 3 family (using Ministral-3-14B-Reasoning-2512 as the representative public template)

{
  "messages": [
    {"role": "user", "content": "Look up and summarize tomorrow's weather in Tokyo"}
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Returns the weather for a city",
        "parameters": {
          "type": "object",
          "properties": {
            "city": {"type": "string"}
          },
          "required": ["city"]
        }
      }
    }
  ]
}

• <think>...</think> family: GLM, Kimi, Qwen, DeepSeek, Phi
• <|think|> or thought channel family: Gemma 4
• [THINK]...[/THINK] family: Ministral Reasoning
• Harmony channels (analysis / commentary / final) family: gpt-oss, LLM-jp-4-thinking

[
  {"role": "user", "content": "Look up and summarize tomorrow's weather in Tokyo"}
]

[
  {
    "type": "function",
    "function": {
      "name": "get_weather",
      "description": "Takes a city name and returns weather information",
      "parameters": {
        "type": "object",
        "properties": {
          "city": {"type": "string"}
        },
        "required": ["city"]
      }
    }
  }
]

• gpt-oss-120b
  • Public artifact: openai/gpt-oss-120b/chat_template.jinja
  • Reasoning representation: analysis channel
  • Control parameter: reasoning_effort=low|medium|high
  • Tool-call representation: Harmony call syntax
• LLM-jp-4-thinking
  • Public artifact: llm-jp/llm-jp-4-8b-thinking/chat_template.jinja
  • Reasoning representation: Harmony analysis channel
  • Control parameter: reasoning_effort=low|medium|high
  • Tool-call representation: Harmony call syntax
• Gemma 4
  • Public artifact: google/gemma-4-E2B-it/chat_template.jinja
  • Reasoning representation: <|think|> / thought channel
  • Control parameter: enable_thinking=True|False
  • Tool-call representation: <|tool>, <|tool_call>, <|tool_response>
• DeepSeek-V3.2
  • Public artifact: deepseek-ai/DeepSeek-V3.2/encoding/encoding_dsv32.py
  • Reasoning representation: <think>...</think>
  • Control parameter: thinking_mode="thinking"|"chat", drop_thinking
  • Tool-call representation: DSML syntax (<｜DSML｜function_calls>)
• Qwen3.5
  • Public artifact: Qwen/Qwen3.5-35B-A3B/tokenizer_config.json
  • Reasoning representation: <think>...</think>
  • Control parameter: enable_thinking=False
  • Tool-call representation: <tool_call><function=...><parameter=...>
• Kimi K2.5
  • Public artifact: moonshotai/Kimi-K2.5/chat_template.jinja
  • Reasoning representation: <think>...</think>
  • Control parameter: thinking on/off (default is on)
  • Tool-call representation: tool_declare, <|tool_calls_section_begin|> family
• Phi-4-reasoning
  • Public artifact: microsoft/Phi-4-reasoning/tokenizer_config.json
  • Reasoning representation: <think>...</think> (fixed system instruction)
  • Control parameter: none applicable
  • Tool-call representation: no tool-call syntax
• GLM-5
  • Public artifact: zai-org/GLM-5-FP8/chat_template.jinja
  • Reasoning representation: <think>...</think>
  • Control parameter: enable_thinking / thinking.type=disabled / clear_thinking
  • Tool-call representation: <tools>...</tools>, <tool_call>...
• Mistral 3 family
  • Public artifact: mistralai/Ministral-3-14B-Reasoning-2512/chat_template.jinja
  • Reasoning representation: [THINK]...[/THINK]
  • Control parameter: the public template is fixed; the API side supports reasoning_effort
  • Tool-call representation: [AVAILABLE_TOOLS], [TOOL_CALLS], [TOOL_RESULTS]

• Hugging Face: openai/gpt-oss-120b/chat_template.jinja
• GitHub: openai/harmony README

• builtin_tools (e.g., ["browser", "python"])
• model_identity
• reasoning_effort ("low", "medium", or "high")

tokenizer.apply_chat_template(
    messages,
    tools=tools,
    builtin_tools=["browser"],
    reasoning_effort="high",
)

<|start|>system<|message|>
You are ChatGPT...
Knowledge cutoff: 2024-06
Current date: 2026-04-05
Reasoning: high
# Valid channels: analysis, commentary, final.
...
<|end|>
<|start|>developer<|message|>
# Tools
## functions
namespace functions {
  type get_weather = (_: { city: string }) => any;
}
<|end|>
<|start|>user<|message|>
Look up and summarize tomorrow's weather in Tokyo
<|end|>

<|start|>assistant<|channel|>analysis<|message|>
Need a weather lookup.
<|end|>
<|start|>assistant to=functions.get_weather<|channel|>commentary json<|message|>
{"city":"Tokyo"}
<|call|>

<|start|>functions.get_weather to=assistant<|channel|>commentary<|message|>
"{\"weather\":\"sunny\"}"
<|end|>

<|start|>assistant<|channel|>final<|message|>
Tomorrow Tokyo will be sunny. ...
<|end|>

• Reasoning: uses the analysis channel of the assistant message.
• Tool integration: uses the commentary channel.
• Final answer: uses the final channel.

• Tool definition: defined inside the developer message in TypeScript namespace form.
• Call instruction: uses the form assistant to=functions.NAME.
• Channel setting: specifies commentary json.
• Arguments: constructed as a JSON payload.
• Terminating tag: uses <|call|>.

• Integrating this model requires a parser and data model dedicated to the Harmony protocol. A generic <think> parser cannot be applied.
• Tool Calling and Reasoning must not be mixed within the same assistant text block; they must be routed using the appropriate channels and destination attributes.

• Hugging Face: llm-jp/llm-jp-4-8b-thinking/chat_template.jinja
• The corresponding model card

• builtin_tools
• model_identity
• reasoning_effort="low"|"medium"|"high"

<|start|>system<|message|>
You are LLM-jp-4...
Knowledge cutoff: 2025-12
Current date: 2026-04-05
Reasoning: medium
# Valid channels: analysis, commentary, final.
<|end|>
<|start|>developer<|message|>
# Tools
## functions
namespace functions {
  type get_weather = (_: { city: string }) => any;
}
<|end|>
<|start|>user<|message|>
Look up and summarize tomorrow's weather in Tokyo
<|end|>

<|start|>assistant<|channel|>analysis<|message|>
First get the weather
<|end|>
<|start|>assistant to=functions.get_weather<|channel|>commentary json<|message|>
{"city":"Tokyo"}
<|call|>

<|start|>assistant<|channel|>final<|message|>
Tomorrow Tokyo will be sunny. ...
<|end|>

• The reasoning process is represented not by <think> tags but as the analysis channel.
• By running the tokenizer.parse_response(response) method, the reasoning part (thinking) and the final answer (content) can be separated.
• The model card explicitly states that a dedicated tokenizer must be used.

• Allowed values: reasoning_effort="low"|"medium"|"high"
• At template evaluation time, the corresponding parameter is embedded into the Reasoning: ... line inside the synthesized system message.

• Definitions using TypeScript-style namespace functions
• Call syntax: assistant to=functions.NAME
• Channel used: commentary json
• Terminating token: <|call|>
• Response format: functions.NAME to=assistant

• While it is compatible with the philosophy of the openai-harmony library, the tokenizer implementation is not completely identical. For safety, it is recommended to use the official tokenizer and parser provided by LLM-jp.
• When running the provided Reasoning parser, there are public examples where, depending on the configuration, enabling the trust_remote_code=True option is required.

• https://huggingface.co/llm-jp/llm-jp-4-8b-thinking/blob/main/chat_template.jinja
• https://huggingface.co/llm-jp/llm-jp-4-8b-thinking

• google/gemma-4-E2B-it/chat_template.jinja
• Official documentation: Thinking mode in Gemma

tokenizer.apply_chat_template(messages, tools=tools, enable_thinking=True)

<|turn>system
<|think|><turn|>
<|tool>
declaration:get_weather{description:..., parameters:{city:string}}
<tool|>
<|turn>user
Look up and summarize tomorrow's weather in Tokyo<turn|>
<|turn>model

• E2B / E4B models: when reasoning is enabled, <|think|> is inserted at the beginning.
• 26B / 31B models: a representation form is documented that opens a thought channel after the model turn.
• The provided template includes a strip_thinking macro that removes the reasoning part when reconstructing history.

• enable_thinking=True|False

• Tool definition: <|tool> ... <tool|>
• Tool call: <|tool_call>call:FUNC{arg:...}<tool_call|>
• Tool-execution result: <|tool_response>response:FUNC{...}<tool_response|>

<|tool_call>call:get_weather{city:<|"|>Tokyo<|"|>}<tool_call|>
<|tool_response>response:get_weather{weather:<|"|>sunny<|"|>}<tool_response|>

• Unlike earlier Gemma specifications, Gemma 4's public template has been updated to generate system turns for reasoning and tool calling.
• When implementing, it is strongly recommended to reference the actual chat_template.jinja file as the source of truth for the specification.

• deepseek-ai/DeepSeek-V3.2/encoding/encoding_dsv32.py

encode_messages(
    messages,
    tools=tools,
    thinking_mode="thinking",
    drop_thinking=True,
    add_default_bos_token=True,
)

• thinking_mode: specify "thinking" or "chat".
• drop_thinking: specifies whether to discard past reasoning history to save context size.

<｜begin▁of▁sentence｜>
## Tools
...
<｜User｜>Look up and summarize tomorrow's weather in Tokyo<｜Assistant｜><think>

<｜DSML｜function_calls>
  <｜DSML｜invoke name="get_weather">
    <｜DSML｜parameter name="city" string="true">Tokyo</｜DSML｜parameter>
  </｜DSML｜invoke>
</｜DSML｜function_calls>

<function_results>
  <result>{"weather":"sunny"}</result>
</function_results>
<think>

• The reasoning process is stored in a <think>...</think> block.
• As delimiters between user and assistant, <｜User｜> and <｜Assistant｜> are used respectively.
• When the assistant's output completes, the reasoning content, answer content, tool calls, and the EOS token are concatenated.

• thinking_mode="thinking": enables reasoning mode.
• thinking_mode="chat": enables a standard conversation mode with reasoning suppressed.
• drop_thinking=True|False: controls whether to retain or discard past reasoning history.

• The function-call block is defined by <｜DSML｜function_calls>.
• Each invoke is given a name attribute specifying the target tool.
• Parameters are defined with <｜DSML｜parameter ...>, and for the string type, string="true" is explicitly specified.
• List-type or object-type data is embedded in JSON format.

• When confirming the prompt-construction specification, you must reference encoding_dsv32.py as the source of truth, not a Jinja template.
• The client side requires a parser implementation dedicated to DeepSeek-V3.2.

• Qwen/Qwen3.5-35B-A3B/tokenizer_config.json
• The model card and quickstart documentation for Qwen/Qwen3.5-9B

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

<|im_start|>system
# Tools
You may call one or more functions...
<tools>
[{"name":"get_weather", ...}]
</tools><|im_end|>
<|im_start|>user
Look up and summarize tomorrow's weather in Tokyo<|im_end|>
<|im_start|>assistant
<think>

<tool_call>
<function=get_weather>
<parameter=city>
Tokyo
</parameter>
</function>
</tool_call>

<|im_start|>user
<tool_response>
{"weather":"sunny"}
</tool_response><|im_end|>

• Default: reasoning feature enabled
• Disable setting: enable_thinking=False

• The schema is defined in the <tools>...</tools> block inside the system prompt.
• The assistant emits a <tool_call> block.
• Tool-execution results are returned in a <tool_response> inside a user turn.
• The reasoning block must be placed before the tool call; placing it after the call is not allowed.

• The template is designed to automatically compress reasoning history that precedes the last user request.
• In a self-hosting environment, you must incorporate Qwen-specific reasoning parsers and tool-call parsers.

• Hugging Face: moonshotai/Kimi-K2.5/chat_template.jinja
• Official documentation: Kimi API Platform (thinking model guide)

extra_body={"thinking": {"type": "disabled"}}

<|im_system|>tool_declare<|im_middle|>
[{"name":"get_weather", ...}]
<|im_end|>
<|im_user|>user<|im_middle|>
Look up and summarize tomorrow's weather in Tokyo
<|im_end|>
<|im_assistant|>assistant<|im_middle|>
<think>

<think>Get the weather first</think>
<|tool_calls_section_begin|>
<|tool_call_begin|get_weather
<|tool_call_argument_begin|>{"city":"Tokyo"}
<|tool_call_end|>
<|tool_calls_section_end|>

## Return of call_1
{"weather":"sunny"}

• The assistant's reasoning process is stored inside a <think>...</think> block.
• Depending on whether Thinking mode is enabled, generation begins with <think> if enabled, or with an empty <think></think> at the beginning if disabled.
• As a Kimi template specification, a compression logic is incorporated that intentionally discards the assistant's Reasoning from past turns and retains only the most recent Reasoning.

• Default state: Thinking mode enabled (on)
• Disable specification: thinking.type="disabled"
• A graduated Effort specification (low/medium/high, etc.) is not supported by the current public template or the official API documentation.

• Tool definition: declared inside a system turn using tool_declare.
• Tool call: uses a dedicated block starting from <|tool_calls_section_begin|>.
• Call arguments: constructed by a sequence of special tokens: tool_call_begin, tool_call_argument_begin, and tool_call_end.
• Tool-execution result: handled as the tool role at the API layer, but converted into plain text of the form Return of <id> inside the prompt.

• When using Thinking mode, it is recommended to restore the reasoning_content of past turns into the history in a complete state.
• Because the template provided by Hugging Face itself has the property of compressing some Reasoning data in the history, take care not to conflate the history-management implementation on the API-client side with the compression policy at the template layer.

• Hugging Face: microsoft/Phi-4-reasoning/tokenizer_config.json
• Model card

<|im_start|>system<|im_sep|>
[Fixed reasoning instruction. Separates Thought and Solution,
prompting to answer in the form <think>{Thought}</think>{Solution}]
<|im_end|>
<|im_start|>user<|im_sep|>
Look up and summarize tomorrow's weather in Tokyo
<|im_end|>
<|im_start|>assistant<|im_sep|>

• The Reasoning content is written inside a <think>...</think> block.
• The output format is not something the user specifies as a system message in the API request; it is enforced by the system prompt automatically inserted by the tokenizer template.
• <think> and </think> are registered as dedicated tokens in the tokenizer vocabulary.

1. Implement the Tool Calling logic in an external agent layer.
2. Position the model itself as a reasoning-only component that generates <think>...</think>.

• Modifying or removing the leading fixed system prompt inserted by the template risks collapsing the model's expected output format.
• When building a parser in a self-hosting environment, the Reasoning parser component of the DeepSeek-R1 family can be repurposed.

• Hugging Face: zai-org/GLM-5-FP8/chat_template.jinja
• Official documentation: GLM-5 overview / Thinking Mode / Function Calling

{"thinking": {"type": "disabled"}}

[gMASK]<sop>
<|system|>
# Tools
You may call one or more functions...
<tools>
[{"name":"get_weather", ...}]
</tools>
<|user|>
Look up and summarize tomorrow's weather in Tokyo
<|assistant|>
<think>

<think>First use the weather tool</think>
<tool_call>
get_weather
<arg_key>city</arg_key><arg_value>Tokyo</arg_value>
</tool_call>

<|observation|>
<tool_response>{"weather":"sunny"}</tool_response>

• The reasoning process is stored inside a <think>...</think> block.
• The template preferentially evaluates the presence of message.reasoning_content, and if there is no such data, it attempts to extract the <think>...</think> block from assistant.content.
• Depending on whether Thinking mode is enabled, the generation start token is <|assistant|><think> (when enabled) or <|assistant|></think> (when disabled).

• Local environment / template: enable_thinking=True|False
• Hosted API: thinking.type="disabled"
• Multi-turn history retention: clear_thinking=false

• The API input layer uses the OpenAI-compatible tools / tool_calls format.
• When converted into the model input prompt, it is reconstructed into <tools>...</tools> and <tool_call>...</tool_call> blocks.
• Tool-execution results are handled as <tool_response>...</tool_response> blocks.

• If you have a requirement to continue Reasoning across multiple turns, explicitly specify clear_thinking=false.
• When building a self-hosting environment, you need to implement dedicated Reasoning parsers and tool parsers specialized for the GLM family.

• Open-weight model: uses the standard messages and tools parameters.
• Hosted API models:
  • mistral-small-latest: graduated adjustment via the reasoning_effort parameter is supported.
  • magistral-small-latest / magistral-medium-latest: these are native Reasoning models, and Thinking processing is always performed.

[SYSTEM_PROMPT]...[/SYSTEM_PROMPT]
[AVAILABLE_TOOLS][{"name":"get_weather",...}][/AVAILABLE_TOOLS]
[INST]Look up and summarize tomorrow's weather in Tokyo[/INST]

[THINK]First get the weather[/THINK]
[TOOL_CALLS]get_weather[ARGS]{"city":"Tokyo"}

[TOOL_RESULTS]{"weather":"sunny"}[/TOOL_RESULTS]

• In the open-weight template, the Reasoning process is stored inside a [THINK]...[/THINK] block.
• The system prompt is structured on the premise that the model outputs Reasoning.
• The assistant content adopts an architecture that splits processing into thinking chunks and text chunks.

• Open-weight model: the public chat_template.jinja has no dynamic parameters such as low|medium|high, and it functions as a fixed Reasoning mode.
• Hosted API models: mistral-small-latest allows adjustment via reasoning_effort. Also, native models (magistral-*) output Thinking chunks without any additional parameter specification.

• Definition: [AVAILABLE_TOOLS]...[/AVAILABLE_TOOLS]
• Call: [TOOL_CALLS]name[ARGS]{json}
• Execution result: [TOOL_RESULTS]...[/TOOL_RESULTS]

• Note that the Mistral-family tags are not the common XML-style <think>, but the bracket-based [THINK].
• Because it is not public how the Hosted API's reasoning_effort parameter is processed into the internal prompt, when implementing a strict parser it is recommended to conform to the open-weight specification.

• Target models: GLM-5, Kimi K2.5, Qwen3.5, DeepSeek-V3.2, Phi-4-reasoning
• Characteristics:
  • The parser is relatively easy to implement.
  • However, the Tool Calling grammar adopts each vendor's own specification and is not standardized.

• Target models: Ministral-3-Reasoning ([THINK]...[/THINK]), Gemma 4 (<|think|> or thought channel)
• Characteristics:
  • The delimiter as a Special Token is strictly defined.
  • It may be difficult to repurpose a standard <think> parser.

• Target models: gpt-oss-120b, LLM-jp-4-thinking
• Characteristics:
  • Reasoning process: uses the analysis channel
  • Tool calls: use the commentary channel
  • Final answer: uses the final channel

• Target models: gpt-oss-120b, LLM-jp-4-thinking
• Specification:
  • Supports explicit parameter input of low|medium|high.
  • The specified value is passed as a template argument (kwargs) and is expanded directly inside the synthesized system message in the form Reasoning: high.
  • The parser and serving environment generally assume the Harmony specification.

• Target models: GLM-5, Kimi K2.5, Qwen3.5, Gemma 4
• Specification:
  • Controls not the reasoning depth but whether the Reasoning channel itself is output.
  • Representative parameter settings use enable_thinking=False or thinking.type=disabled.

• Target model: DeepSeek-V3.2
• Specification:
  • On the API interface, the mode is selected as an Enum value such as thinking_mode="thinking"|"chat".
  • The compression control of reasoning history is managed by an independent parameter (drop_thinking).

• Target models: Phi-4-reasoning, open-weight Ministral-3-Reasoning
• Specification:
  • The Reasoning format is statically defined (hard-coded) inside the prompt template.
  • A use case of dynamically adjusting the reasoning depth (Effort) from external parameters is not assumed.

• XML / pseudo-XML type: defined using XML-like tags such as <tools> or <tool_call>. The applicable models are GLM-5, Qwen3.5, and DeepSeek-V3.2 (DSML).
• Dedicated special-token type: defines the structure using model-specific special system tokens (e.g., <|tool|>). The applicable models are Kimi K2.5 and Gemma 4.
• Delimiter-string type: delimits blocks using a specific string such as [AVAILABLE_TOOLS]. The applicable model is Ministral-3-Reasoning.
• Protocol / channel type: an advanced configuration that splits messages into logical channels for processing. The applicable models are gpt-oss-120b and LLM-jp-4-thinking.

Note: When implementing a tool-call-capable server, it is not recommended to base it solely on the OpenAI-compatible JSON format (messages, tools, tool_calls). Because the syntax specification actually fed to the model differs greatly from model to model, you need to implement model-specific parsers on the backend side.

• Reasoning feature present, no Effort specification: Phi-4, Ministral (open-weight version), DeepSeek (thinking mode)
• Reasoning feature present, binary enable/disable control: GLM, Kimi, Qwen, Gemma
• Reasoning feature present, multi-level Effort specification: gpt-oss, LLM-jp, Mistral API (managed version)

• Discards the thinking process from history during inference: gpt-oss, LLM-jp, Kimi, Qwen, DeepSeek (when the drop_thinking=True parameter is specified)
• Retention via an explicit parameter: GLM (when the clear_thinking=false parameter is specified)
• Control via a fixed system prompt: Phi-4

• Llama 4: The existence of Instruct models (such as meta-llama/Llama-4-Scout-17B-16E-Instruct) is confirmed, but no public information on a Reasoning-specific chat template, Effort specification, or tool syntax could be confirmed.
• OLMo 2: Ordinary chat templates (such as allenai/OLMo-2-1124-13B-Instruct) are provided, but no specification for a Reasoning-specific template or Effort parameter is public.

• Model group with the clearest text-based Reasoning representation: GLM-5, Kimi K2.5, Qwen3.5, DeepSeek-V3.2, Phi-4-reasoning
• Model group that is protocol-oriented and requires a dedicated parser implementation: gpt-oss-120b, LLM-jp-4-thinking
• Model group with its own tool syntax and high parser-implementation difficulty: DeepSeek-V3.2 (DSML), Gemma 4, Kimi K2.5
• Model group with an explicit Reasoning Effort API specification: gpt-oss-120b, LLM-jp-4-thinking, Mistral (managed API version)

• Template: https://huggingface.co/openai/gpt-oss-120b/blob/main/chat_template.jinja
• Repository: https://huggingface.co/openai/gpt-oss-120b
• Harmony: https://github.com/openai/harmony/blob/main/README.md

• Template: https://huggingface.co/llm-jp/llm-jp-4-8b-thinking/blob/main/chat_template.jinja
• Repository: https://huggingface.co/llm-jp/llm-jp-4-8b-thinking

• Template: https://huggingface.co/google/gemma-4-E2B-it/blob/main/chat_template.jinja
• Documentation: https://ai.google.dev/gemma/docs/capabilities/thinking

• Encoder: https://huggingface.co/deepseek-ai/DeepSeek-V3.2/blob/main/encoding/encoding_dsv32.py
• Repository: https://huggingface.co/deepseek-ai/DeepSeek-V3.2

• Tokenizer: https://huggingface.co/Qwen/Qwen3.5-35B-A3B/blob/main/tokenizer_config.json
• Model card: https://huggingface.co/Qwen/Qwen3.5-9B
• Quickstart: https://qwen.readthedocs.io/en/latest/getting_started/quickstart.html
• Inference: https://qwen.readthedocs.io/en/latest/inference/transformers.html

• Template: https://huggingface.co/moonshotai/Kimi-K2.5/blob/main/chat_template.jinja
• Documentation: https://huggingface.co/moonshotai/Kimi-K2.5/blob/main/README.md
• Guide: https://platform.moonshot.ai/docs/guide/use-kimi-k2-thinking-model.en-US
• Overview: https://platform.moonshot.ai/docs/overview

• Tokenizer: https://huggingface.co/microsoft/Phi-4-reasoning/blob/main/tokenizer_config.json
• Repository: https://huggingface.co/microsoft/Phi-4-reasoning

• Template: https://huggingface.co/zai-org/GLM-5-FP8/blob/main/chat_template.jinja
• Documentation: https://huggingface.co/zai-org/GLM-5-FP8/blob/main/README.md
• API specification: https://docs.z.ai/guides/llm/glm-5
• Thinking Mode: https://docs.z.ai/guides/capabilities/thinking-mode
• Function Calling: https://docs.z.ai/guides/capabilities/function-calling

• Template: https://huggingface.co/mistralai/Ministral-3-14B-Reasoning-2512/blob/main/chat_template.jinja
• Reasoning specification: https://docs.mistral.ai/capabilities/reasoning
• Native Reasoning: https://docs.mistral.ai/capabilities/reasoning/native

• Llama 4: https://huggingface.co/meta-llama/Llama-4-Scout-17B-16E-Instruct
• OLMo 2: https://huggingface.co/allenai/OLMo-2-1124-13B-Instruct