HyperCLOVA X SEED 14B Think is a next-generation language model that moves beyond the conventional approach of simply increasing model size to improve performance. It combines HyperCLOVA X’s lightweighting technology for building high-efficiency LLMs with advanced reasoning capabilities. Its development relied on two key technologies: (1) Pruning & Knowledge Distillation, which achieves both compactness and high performance, and (2) a Reinforcement Learning (RL) pipeline, which maximizes reasoning ability. By pruning low-importance parameters and distilling knowledge from a large model into a smaller one, training costs have been significantly reduced. On top of this, the latest RL recipe validated in HyperCLOVA X Think is applied in a multi-stage process: (1) Supervised Fine-Tuning (SFT), (2) Reinforcement Learning with Verifiable Rewards (RLVR), (3) Length Controllability (LC) for reasoning path optimization, and (4) a joint training of Reinforcement Learning from Human Feedback (RLHF) and RLVR.
It is a considerable challenge to equip a pruned, knowledge-distilled model with reasoning capabilities, since reductions in training costs and model size often degrade reasoning performance. However, through extensive research experience and persistent trial and error, the HyperCLOVA X team has succeeded in lowering training costs while maintaining reasoning performance comparable to that of larger, resource-intensive models.
Basic Information
Architecture : Transformer-based architecture with Peri-Layer Normalization and Maximal Update Parameterization(μP) (Dense Model)
Parameters : 14.74B
Input/Output Format (Input/Output) : Text / Text
Context Length : 32k
Training Cost
HyperCLOVA X SEED 14B Think was trained at a significantly lower cost compared to high-performance external models of similar scale. By utilizing HCX’s lightweight training pipeline, it was trained at approximately 52.60× lower cost than Qwen2.5-14B and 91.38× lower cost than Qwen3-14B.
Model (Base)
GPU Hours (A100-80GB, MFU 50%)
HyperCLOVA X SEED 14B Think
68,049
Qwen2.5-0.5B
169,257
Qwen2.5-1.5B
449,643
Qwen3-0.6B
602,460
Qwen3-1.7B
1,063,991
HyperCLOVA X Think
2,197,732
Qwen2.5-14B
3,603,432
Qwen3-8B
3,993,607
Qwen3-14B
6,267,077
Qwen3-32B
14,108,748
Benchmarks
Compared to global models of a similar scale, such as Qwen3 14B, HyperCLOVA X SEED 14B Think demonstrates superior performance in Korean language and cultural understanding, while showing competitive performance in math and coding tasks, which are directly or indirectly related to agent capabilities. This trend remains consistent even when compared with larger models like Qwen3 32B and LG Exaone-Deep 32B.
Given a two-turn conversation between the user and the assistant (user_query_1, assistant_answer_1, user_query_2, assistant_answer_2), the prompt for the first-turn can be constructed in its simplest form as follows:
<|im_start|>tool_list
<|im_end|>
<|im_start|>system
- You are "CLOVA X," an AI language model developed by NAVER.
- The current date is {day of the week}, {month} {dd}, {yyyy}.<|im_end|>
<|im_start|>user
{user_query_1}<|im_end|>
<|im_start|>assistant
After the <|im_end|> token (indicating the end of the ChatML block), the model generates text up to the <|endofturn|> token. This output corresponds to the assistant's first response (assistant_answer_1).
Second turn
Based on the assistant's first response (assistant_answer_1), when the user asks an additional question (user_query_2), the prompt input to the model is constructed as follows:
{following the previous context}
{assistant_answer_1}<|im_end|><|endofturn|>
<|im_start|>user
{user_query_2}<|im_end|>
<|im_start|>assistant
As in the previous turn, generation continues until the <|endofturn|> token appears after <|im_end|>. This corresponds to the assistant's second response (assistant_answer_2).
(ChatML) Function Call (Using Tools)
Insert the list of tools available into the tool_list block as a JSON list. For example, the following is a case where the only available tool is get_weather.
<|im_start|>tool_list
[{"name": "get_weather", "description": "Check the current weather at the requested location.", "parameters": {"type": "object", "properties": {"location": {"type": "string", "description": "Name of the city"}}, "required": ["location"]}}]<|im_end|>
Additional instructions can be included in the system prompt if needed, and it is recommended to format them as - {content}. For example:
<|im_start|>system
- In this environment, various tools can be used to answer users' questions.
- You are "CLOVA X," an AI language model developed by NAVER.
- Begin by creating a plan for solving the problem, and then utilize the tools accordingly to address the problem.
- The current date is {day of the week}, {month} {dd}, {yyyy}.
- Latest information such as news, stock prices, and shopping is retrieved through the tool_list.
- If external tools are required, the assistant should not answer directly but must first obtain the necessary information via the assistant -> tool/function_call role, and then respond.<|im_end|>
First turn
Suppose the user gives the instruction, 'Tell me the weather in Seoul.' The prompt input to the model would then be as follows:
<|im_start|>tool_list
[{"name": "get_weather", "description": "Check the current weather at the requested location.", "parameters": {"type": "object", "properties": {"location": {"type": "string", "description": "Name of the city"}}, "required": ["location"]}}]<|im_end|>
<|im_start|>system
- In this environment, various tools can be used to answer users' questions.
- You are "CLOVA X," an AI language model developed by NAVER.
- Begin by creating a plan for solving the problem, and then utilize the tools accordingly to address the problem.
- The current date is {day of the week}, {month} {dd}, {yyyy}.
- Latest information such as news, stock prices, and shopping is retrieved through the tool_list.
- If external tools are required, the assistant should not answer directly but must first obtain the necessary information via the assistant -> tool/function_call role, and then respond.<|im_end|>
<|im_start|>user
Tell me the weather in Seoul<|im_end|>
<|im_start|>assistant
Generation continues until either the <|stop|> or <|endofturn|> token appears immediately after <|im_end|>. An example of the model’s output is shown below. HyperCLOVA X checks the list of available tools (tool_list), selects the appropriate tool (get_weather), and returns the necessary information for the tool call in JSON format.
{following the previous context}
Let's check the weather using the get_weather tool.<|im_end|>
<|im_start|>assistant -> tool/function_call
{"name": "get_weather","input": {"location":"Seoul"}}<|im_end|><|stop|>
assistant -> tool/function_call means that the assistant(model) invokes a function call.
Second turn
The model stopped generating because <|stop|> token appeared immediately after <|im_end|>. Based on the information generated, get_weathershould now be called. Calling an external function and parsing the result must be implemented additionally. For explanation, let's assume that the result of calling and parsing an external function is {"result":{"location": "Seoul", "weather": "Sunny", "temperature": 25}}.
The model is now ready to respond to the second turn. Using all the information gathered so far, input the following prompt into the model and have it follow accordingly.
tool/function_call means it should pass the result of the function call to the assistant(model).
Just like in the previous turn, generation continues until the <|stop|> or <|endofturn|> token appears immediately after <|im_end|>. If the model behaves as expected, the output will look like this.
{following the previous context}
The weather in Seoul is clear and the temperature is 25 degrees.<|im_end|><|endofturn|>
(ChatML) Inducing reasoning/non-reasoning
HyperCLOVA X can handle both reasoning and non-reasoning tasks. There is a difference depending on whether the assistant is prompted to 'think' before responding. Based on the previous example, to make HyperCLOVA X respond in reasoning mode, you can input the prompt into the model as follows (excluding the tool_list and system)
<|im_start|>user
Tell me the weather in Seoul<|im_end|>
<|im_start|>assistant/think
Note that the prompt ends with assistant/think\n(think + `\n).
Generation continues until either the <|stop|> or <|endofturn|> token appears immediately after <|im_end|>.
To have the assistant respond in non-reasoning mode (i.e., answer directly), you can input the following prompt.
<|im_start|>user
Tell me the weather in Seoul<|im_end|>
<|im_start|>assistant
Note that the prompt ends with assistant\n(assistant + \n).
Generation continues until either the <|stop|> or <|endofturn|> token appears immediately after <|im_end|>.
Adjusting inference length
The length of reasoning can be controlled by appending "\nThink for maximum {N} tokens" at the end of the user's utterance.
Example
Suppose the user says, "Tell me the prime number closest to 1000."
If you want the model to reason for approximately 1024 tokens before answering, you would construct the prompt as follows:
<|im_start|>tool_list
<|im_end|>
<|im_start|>system
- You are "CLOVA X," an AI language model developed by NAVER.
- The current date is {day of the week}, {month} {dd}, {yyyy}.<|im_end|>
<|im_start|>user
Tell me the prime number closest to 1000.
Think for maximum 1024 tokens.<|im_end|>
<|im_start|>assistant/think
Adjusting the reasoning length means guiding the model to reason for approximately the specified number of tokens; it does not always generate for exact number of tokens given.
Multiturn inference
When engaging in multi-turn conversations with reasoning enabled, the reasoning content from previous turns (<|im_start|>assistant/think\n...<|im_end|>) is not included in the next turn's prompt. Instead, as in the standard multi-turn dialogue format, only the final assistant response is included in the prompt passed to the model.
The same applies when a function call is made during reasoning: the reasoning content is excluded, and only the function call block (<|im_start|>assistant -> tool/function_call\n...<|im_end|><|stop|>) is included in the prompt provided to the model.
Example: Solving a simple math problem
Suppose the user sends a request: "Calculate the sum of odd numbers from 1 to 10."
The following explains step-by-step how this is processed as a multi-turn reasoning interaction.
First Turn
Input Prompt
<|im_start|>tool_list
<|im_end|>
<|im_start|>system
<|im_end|>
<|im_start|>user
Calculate the sum of odd numbers from 1 to 10
<|im_end|>
<|im_start|>assistant/think
The model begins to generate inference contents.
{following the previous context}
The user wants me to find the sum of the odd numbers from 1 to 10. First, I need to clearly understand the problem. I should identify which numbers between 1 and 10 are odd. Going through the numbers in order, the odd numbers are 1, 3, 5, 7, and 9. Since 10 is even, it is excluded. Now, I need to add these numbers together. Adding them step by step: 1+3=4, plus 5 gives 9, plus 7 gives 16, and finally adding 9 gives 25. But is there another way to calculate this? For example, I could use the formula for the sum of an arithmetic sequence. The odd numbers here form an arithmetic sequence with the first term 1 and a common difference of 2. I need to count the number of terms first—there are 5 odd numbers between 1 and 10. The formula for the sum of an arithmetic sequence is n*(a₁ + aₙ)/2, where n is 5, a₁ is 1, and aₙ is 9. Plugging these in, we get 5*(1 + 9)/2 = 5*10/2 = 25, which matches the previous result. Since both methods give 25, I’ll double-check that this is the answer the user expects, and then provide a concise explanation.<|im_end|>
<|im_start|>assistant
The odd numbers from 1 to 10 are **1, 3, 5, 7, 9**.
The sum of these numbers is calculated as follows:
\[
1 + 3 + 5 + 7 + 9 = 25
\]
Alternatively, the sum can be easily calculated using **the formula for the sum of an arithmetic sequence**:
- First term (\(a_1\)) = 1
- Last term (\(a_n\)) = 9
- Number of terms (\(n\)) = 5
\[
\text{Sum} = \frac{n(a_1 + a_n)}{2} = \frac{5 \times (1 + 9)}{2} = \frac{5 \times 10}{2} = 25
\]
**Result:** The answer is **25**.<|im_end|><|endofturn|>
As the <|endofturn|> token has been generated, the model concludes the current turn and awaits the next user input.
Second Turn
Suppose you want to follow up with: "What is the result of adding 10 to that sum?" Here, the prompt is created by excluding the reasoning content (assistant/think) from the first turn and including only the final response (assistant).
Input Prompt
<|im_start|>tool_list
<|im_end|>
<|im_start|>system
<|im_end|>
<|im_start|>user
Calculate the sum of odd numbers from 1 to 10
<|im_end|>
<|im_start|>assistant
The odd numbers from 1 to 10 are **1, 3, 5, 7, 9**.
The sum of these numbers is calculated as follows:
\[
1 + 3 + 5 + 7 + 9 = 25
\]
Alternatively, the sum can be easily calculated using **the formula for the sum of an arithmetic sequence**:
- First term (\(a_1\)) = 1
- Last term (\(a_n\)) = 9
- Number of terms (\(n\)) = 5
\[
\text{Sum} = \frac{n(a_1 + a_n)}{2} = \frac{5 \times (1 + 9)}{2} = \frac{5 \times 10}{2} = 25
\]
**Result:** The answer is **25**.<|im_end|><|endofturn|>
<|im_end|>
<|im_start|>user
What is the result of adding 10 to that sum?
<|im_end|>
<|im_start|>assistant/think
Excluded contents in the second turn input
<|im_start|>assistant/think
{following the previous context}
The user wants me to find the sum of the odd numbers from 1 to 10. First, I need to clearly understand the problem. I should identify which numbers between 1 and 10 are odd. Going through the numbers in order, the odd numbers are 1, 3, 5, 7, and 9. Since 10 is even, it is excluded. Now, I need to add these numbers together. Adding them step by step: 1+3=4, plus 5 gives 9, plus 7 gives 16, and finally adding 9 gives 25. But is there another way to calculate this? For example, I could use the formula for the sum of an arithmetic sequence. The odd numbers here form an arithmetic sequence with the first term 1 and a common difference of 2. I need to count the number of terms first—there are 5 odd numbers between 1 and 10. The formula for the sum of an arithmetic sequence is n*(a₁ + aₙ)/2, where n is 5, a₁ is 1, and aₙ is 9. Plugging these in, we get 5*(1 + 9)/2 = 5*10/2 = 25, which matches the previous result. Since both methods give 25, I’ll double-check that this is the answer the user expects, and then provide a concise explanation.<|im_end|>
For all later turns, the reasoning (think) content from previous turns is not added to the prompt as well.
Difference between <|stop|> and <|endofturn|>
Similarity
They both act as signals to stop the model from generating further responses.
Difference
<|stop|>: After the response generation is halted and the tool_invoke results are processed, the AI turn resumes.
<|endofturn|>: After the response generation is halted, the AI turn is fully terminated, and the model waits for the user's next input.
Huggingface Usage Example
After downloading the model binaries, including the configuration files, to a local path(/path/to/hyperclova-x-seed-think-14b), you can run the following in a Python environment with the Huggingface library (verified to work with version >= 5.9.0) installed.
You can use the apply_chat_template parameter to explicitly enable or disable the reasoning feature.
The default value for both options is None, in which case the model decides on its own whether to reason before answering or to answer directly without reasoning.
force_reasoning=True: Forces the model to always reason before answering.
skip_reasoning=True: Forces the model to answer directly without reasoning.
Passing None or False has the same effect.
If both are set to True, force_reasoning=True takes precedence.
python
1# Default example2inputs = tokenizer.apply_chat_template(chat, add_generation_prompt=True, return_dict=True, return_tensors="pt")34# By adding force_reasoning=True, the model is forced to always reason before responding5inputs = tokenizer.apply_chat_template(chat, add_generation_prompt=True, force_reasoning=True, return_dict=True, return_tensors="pt")67# By adding skip_reasoning=True, the model is forced to always answer directly without reasoning8inputs = tokenizer.apply_chat_template(chat, add_generation_prompt=True, skip_reasoning=True, return_dict=True, return_tensors="pt")
Basic Example Code
The example below runs the model in hybrid mode (the model decides whether to reason).
To force a specific mode, replace the inputs = ... line with one of the commented alternatives.
python
1from transformers import AutoModelForCausalLM, AutoTokenizer
23model_name ="naver-hyperclovax/HyperCLOVAX-SEED-Think-14B"4model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto")5tokenizer = AutoTokenizer.from_pretrained(model_name)67chat =[8{"role":"system","content":"- In this environment, various tools can be used to answer users' questions.\n- You are \"CLOVA X,\" an AI language model developed by NAVER.\n- Begin by creating a plan for solving the problem, and then utilize the tools accordingly to address the problem.\n- The current date is Monday, July 21, 2025.\n- Latest information such as news, stock prices, and shopping is retrieved through the tool_list.\n- If external tools are required, the assistant should not answer directly but must first obtain the necessary information via the assistant -> tool/function_call role, and then respond."},9{"role":"user","content":"Explain in as much detail as possible the relationship between the Schrödinger equation and quantum mechanics."},10]1112# Hybrid (default): the model decides whether to reason before answering.13inputs = tokenizer.apply_chat_template(chat, add_generation_prompt=True, return_dict=True, return_tensors="pt")14# Think mode: inputs = tokenizer.apply_chat_template(chat, add_generation_prompt=True, force_reasoning=True, return_dict=True, return_tensors="pt")15# Non-think mode: inputs = tokenizer.apply_chat_template(chat, add_generation_prompt=True, skip_reasoning=True, return_dict=True, return_tensors="pt")16inputs = inputs.to("cuda")1718output_ids = model.generate(19**inputs,20 max_length=1024,21 stop_strings=["<|endofturn|>","<|stop|>"],22 temperature=0.5,23 top_p=0.6,24 repetition_penalty=1.05,25 tokenizer=tokenizer
26)27print(tokenizer.batch_decode(output_ids))
Example code for function calls (tool usage)
For a scenario involving tool usage, you can execute it as follows.
python
1import json
2from transformers import AutoModelForCausalLM, AutoTokenizer
34model_name ="naver-hyperclovax/HyperCLOVAX-SEED-Think-14B"5model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto")6tokenizer = AutoTokenizer.from_pretrained(model_name)78# 1) The name of the tool should be written as function_call.{{ name }}.9# 2) Parameters follow the specifications described at https://platform.openai.com/docs/guides/function-calling?api-mode=responses.10tool_list =[11{12"type":"function",13"function":{14"name":"add",15"description":"Add two numbers.",16"parameters":{17"type":"object",18"properties":{19"x":{"type":"number","description":"First number"},20"y":{"type":"number","description":"Second number"}21},22"required":["x","y"]23}24}25},{26"type":"function",27"function":{28"name":"subtract",29"description":"Subtract two numbers.",30"parameters":{31"type":"object",32"properties":{33"x":{"type":"number","description":"First number"},34"y":{"type":"number","description":"Second number"}35},36"required":["x","y"]37}38}39}40]414243chat =[44{"role":"system","content":"- In this environment, various tools can be used to answer users' questions.\n- You are \"CLOVA X,\" an AI language model developed by NAVER.\n- Begin by creating a plan for solving the problem, and then utilize the tools accordingly to address the problem.\n- The current date is Monday, July 21, 2025.\n- Latest information such as news, stock prices, and shopping is retrieved through the tool_list.\n- If external tools are required, the assistant should not answer directly but must first obtain the necessary information via the assistant -> tool/function_call role, and then respond."},45{"role":"user","content":"What is 1588 + 1234? Please calculate it using the provided tool."},46]4748inputs = tokenizer.apply_chat_template(chat, tools=tool_list, add_generation_prompt=True, return_dict=True, return_tensors="pt")49inputs = inputs.to("cuda")5051output_ids = model.generate(52**inputs,53 max_length=1024,54 stop_strings=["<|endofturn|>","<|stop|>"],55 temperature=0.5,56 top_p=0.6,57 repetition_penalty=1.05,58 tokenizer=tokenizer
59)60print(tokenizer.batch_decode(output_ids))
If you have any questions or issues regarding usage, please leave them as an issue in the Discussions section of this page.
vLLM Usage Example
The HyperCLOVA X SEED Think model is natively supported by vLLM. After installing vLLM, you can serve the model directly.
Sampling parameters such as top_k, temperature, top_p, repetition_penalty, and max_tokens can be set freely.
However, the skip_special_tokens and stop options must be set as below for vLLM to recognize the model's token generation stop signal and cease generation.
bash
1curl -X POST http://localhost:8000/v1/chat/completions \2-H "Content-Type: application/json"\3-d '{
4 "model": "naver-hyperclovax/HyperCLOVAX-SEED-Think-14B",
5 "messages": [
6 {"role": "system", "content": "- The AI language model is named \"CLOVA X\" and was developed by NAVER.\n- Today is Friday, July 18, 2025."},
7 {"role": "user", "content": "Explain in as much detail as possible the relationship between the Schrödinger equation and quantum mechanics."}
8 ],
9 "skip_special_tokens": false,
10 "stop": ["<|im_end|><|endofturn|>", "<|im_end|><|stop|>"],
11 "top_k": -1,
12 "temperature": 0.5,
13 "top_p": 0.6,
14 "repetition_penalty": 1.05,
15 "max_tokens": 8192
16}'
Controlling Reasoning Mode
Use chat_template_kwargs in the request body to control reasoning behavior:
{"force_reasoning": true} — Always reason before answering.
{"skip_reasoning": true} — Always answer directly without reasoning.
If neither is given, the model decides on its own.
If both are set to true, force_reasoning takes priority.
Example:
"chat_template_kwargs": {"force_reasoning": true}
Note: Native --reasoning-parser and --tool-call-parser support for HyperCLOVA-X is not yet available in vLLM upstream. To extract reasoning_content and tool_calls as structured response fields, please refer to the hcx-vllm-plugin repository.
